Freshmaking!

This stuff is fairly basic, and exists as a base for future posts mostly.

If you’re an old, early-twenties fogey such as myself, you can remember back to a time when it cost a few grand to buy a computer which, instead of using a hard disk drive, took floppy disks the size of your head. Still, even in that ancient age, people knew that “computers talk in ones and zeros”. That’s right. If you don’t know the first thing about computers, you still know they speak in binary.

These ones and zeros work really well for integral values, but computers will choke and gag on fractional values more often than you realize. And I’m not just talking about ultra tiny fractions representing the width of a grain of sand in miles… even for simple stuff. Consider the following classic example:

#include <iostream>

int main(int argc, char *argv[])
{
	float one_tenth = 0.1f;
	float total = 0.0f;

	for(int i=0;i<1000;i++)
		total += one_tenth;
	std::cout << total;

	std::cin.get();
}

The program is pretty straightforward. Take a variable (set to 0) and add 0.1 to it a thousand times. If you don’t feel like whipping out a calculator and adding 0.1 over and over again, then trust me–the answer will be 100. So we hit compile, kick back, and get ready to bask in the glow of the 100 that’s about to be printed to our screen:

99.99

Ahh… enjoy that beautiful 100 glow. Wait, 99.99? What? I mean it’s just adding 0.1 a bunch, so there wouldn’t be any rounding errors, right? RIGHT?!?

The price is WRONG!
Continue Reading »

So with all of this Guitar Hero and Rock Band garbage going around lately, every kid out there wants to make a rhythm based Flash game. It turns out that there have been some fairly complex attempts at this, and it also turns out that I didn’t know that until AFTER I started looking into it on my own.

The story goes that some random person on a forum asked for some help with this. I suggested using Actionscript’s FFT option on the computeSpectrum function. Some other random person acted like the idea wasn’t worth investigating, so I decided to take a stab at it myself to prove this person wrong. My attempt would be pretty trivial and straightforward, but hopefully a “good start”

Turned out that it was really easy to make excellent beat detection this way. And by “excellent”, I mean “absolutely awful”.

You can check out the finished product here. There’s no preloader, so just wait (2.5mb). Not impressed? Might want to skip this. Think it’s at least *sort of* cool and *potentially useful*? Read on, youngin’!
Continue Reading »

These days there’s this well-seated OOP craze in the CS world. OOP is far from new, but in the relatively recent past (10-20 years?) it has gone from “Oh, that” to rock stardom. Everyone loves to “abstract away from implementation details”. The idea sounds great on paper, but sometimes it’ll bite ya in the ass.

The standard C++ library has a bunch of built in data containers to make your life easier. The most common one is probably the vector. Vectors store their contents in a contiguous block of memory. They can be iterated through very efficiently and make your cache much happier. Vectors also come with a bunch of operations. Some of my favorites are the push_back and pop functions.

How do these functions work internally? Ahh, that’s just a tiny implementation detail! Or IS it?

Let’s say we have the following program:

#include <iostream>
#include <vector>

int main(int argc, char* argv[])
{
	std::vector<char> vowels;

	std::cout << "Setting up our vector of vicious vowels!" << std::endl;
	vowels.push_back('a');
	vowels.push_back('e');
	vowels.push_back('i');
	vowels.push_back('o');

	char* favorite_vowel = &vowels[2]; // Our favorite vowel is i!

	std::cout << "Favorite vowel: " << *favorite_vowel << std::endl;

	std::cout << "WAIT!  We forgot to include 'u'.  Let's stick it on the end of the array!" << std::endl;

	vowels.push_back('u');

	std::cout << "Okay, but my favorite vowel is still: " << *favorite_vowel << std::endl;

	std::cin.get();

	return 0;
}

Your output may be different than mine, but when I compile and run this program, I get the following:

Setting up our vector of vicious vowels!
Favorite vowel: i
WAIT!  We forgot to include 'u'.  Let's stick it on the end of the array!
Okay, but my favorite vowel is still: 3

Wait a second… my favorite vowel isn’t 3. In fact, 3 isn’t a vowel–it isn’t even a letter! And what’s more, there is no 3 in our entire program. So where the hell is our 3 coming from?
Continue Reading »

One post I responded to on a forum was regarding overloaded functions and default parameters–was there any performance difference? I was pretty sure there wasn’t, but I put some time into figuring it out and illustrating the concepts, so I figured I might as well post it here. Most of THIS post is THAT post verbatim. So if you’ve read that post, then there’s nothing new here, really.

“Overloading functions” is a little bit misleading. Having two identically named functions with different parameters doesn’t produce one magical function that sorts itself out with no runtime cost (but overloaded functions don’t have any runtime cost). Overloading a function just puts the work of writing separate function names on the compiler–two independent functions are still generated. For instance, in this program:

Continue Reading »

“Arrays are really just pointers”.

This is one of the biggest “gotchas” out there. It’s one that, at the end of the day, really isn’t even that big of a deal. You could live happily for the rest of your life convinced that arrays and pointers are the exact same thing (though I wouldn’t recommend it). But arrays aren’t pointers. They decay into pointers. Plus you can’t change where they point to, but that really isn’t the point here..

Before I go on, I want to pick this very obvious spot to point out that everything I’m about to explain was pulled almost entirely from this thread on gamedev, including most of the program below (with other, clearer versions in the thread). Reading through that post will probably benefit you much more than reading through this one, especially the parts on the extra indirection after a function call towards the end, which won’t be mentioned here.

Anyway, take the following code:

#include <iostream>
#include <string>

static const size_t ARRAY_SIZE=5;

void display_array_info(int size, const std::string &title)
{
	std::cout << title << std::endl;
	std::cout << "Array size: " << size << std::endl;
}

template <typename T, size_t U>
void reference(const T (&some_array)[U])
{
	display_array_info(sizeof(some_array), "By Reference:");
}
template <typename T, size_t U>
void value(const T some_array[])
{
	display_array_info(sizeof(some_array), "By \"Value\":");
}

template <typename U>
void pointer(const U* const some_array)
{
	display_array_info(sizeof(some_array), "By Pointer:");
}

int main(int argc, char *argv[]) {
	int integer_array[ARRAY_SIZE] = { 2, 4, 6, 8, 10 };

	std::cout << "From Main:" << std::endl;
	std::cout << "Array size: " << sizeof(integer_array) << std::endl;

	pointer<int>(integer_array);
	value<int, ARRAY_SIZE>(integer_array);
	reference<int, ARRAY_SIZE>(integer_array);

	std::cin.get();

	return 0;
}

Which, for me, will output:

From Main:
Array size: 20
By Pointer:
Array size: 4
By "Value":
Array size: 4
By Reference:
Array size: 20

(the array takes up 20 bytes in total…)

So what exactly is going on here?
Continue Reading »

Heya!

Thank you one-click Dreamhost install. If you wanna know a little bit more about why this site is taking up space on the internet, check out the About page.

For the time being, I’m just going to copy and paste some replies I’ve made on some forums. Needless to say they’ll be a rough fit at first, as I wasn’t authoring them for this site. I’ll edit them in the coming days until they fit more a little bit better, then see about moving forward