SDLTutorials.com » C++ tutorials

C++ Variables

Tim Jones — Wed, 17 Mar 2010 12:11:51 +0000

Congrats. You are one tutorial closer in the wonderful world of programming. Up to now, you should be somewhat comfortable with CodeBlocks, and have a very basic understanding of how a program works. In this tutorial we are going to look at something called variables.

A variable in the programming world is a special type of container that can hold a value. This container is then stored in memory with its value. In other words, your program can make a request to the operating system to store a value into memory, and then later on, it can request that value back at any time. This is useful for a lot of reasons, especially when you need to do calculations.

There are several types of values you can store into memory. Here’s a list of some of them:

Keyword	Type	Size*
char	Character/Small Integer	1 Byte
short int	Short Integer	2 Bytes
int	Integer	4 Bytes
long int	Long Integer	4 Bytes
long long int	Long Integer (64-bits)	8 Bytes
float	Single-precision floating point value	4 Bytes
double	Double-precision floating point value	8 Bytes

*Please note that the sizes listed here are simply for reference and based upon commonality. Some machines are different.

So what does this table mean really? Well, each variable keyword can basically hold a certain size, or, in other words, each variable keyword says how much memory we are going to take up. So, for example, if we wanted to store the user’s age into a variable, a good choice would be short int. Why? Because short int doesn’t take up very much memory, and we don’t expect people to start living to thousands of years of age anytime soon. But lets say we are storing the average age between 10 people, and lets say the average we come up with is 20.7. We would use a float type to store this value because floats can store decimals (that is what “floating point value” means). Look at it this way:

Can hold integer values:
char, short int, int, long int, long long int

Can hold floating point values:
float, double

Those that hold integer values have nothing different between them other than the amount of data they can store. Same goes for floating point types. Take a look at the chart again, but this time with limits in place:

Keyword	Type	Size
char	Character/Small Integer	0 – 255
short int	Short Integer	0 to 65535
int	Integer	0 to 4294967295
long int	Long Integer	0 to 4294967295
long long int	Long Integer (64-bits)	0 to 18446744073709551615
float	Single-precision floating point value	+/- 3.4e +/- 38 (~7 digits)
double	Double-precision floating point value	+/- 1.7e +/- 308 (~15 digits)

(Please note table data was taken from http://www.cplusplus.com/doc/tutorial/variables/ and http://home.att.net/~jackklein/c/inttypes.html#long_long).

You can see, depending on what you need to store into memory, you can choose the appropriate data type. We don’t want our program to take up all memory on the system, so we must choose the appropriate data types. Notice that int and long int are shown as the same. As I mentioned above, not all systems set these sizes / ranges the same, long int may actually be larger than int on some systems. Also, please note that char, though a rather small integer type, is special in the regard that is can hold characters (letters, and such). We’ll get into that aspect in later tutorials.

So why is this all important? First, we need to know our limitations when dealing with data. Secondly, we need to know which data types to use when we do need to store data.

If you notice from the table above there doesn’t seem to be a way to hold negative values. C++ deals with this by introducing two keywords called unsigned / signed. Unsigned means the data type will only hold positive values (including 0). Signed means the data type can hold negative and positive values, but when you make a variable signed, that effectively cuts the positive range in half. For example:

signed char
Range: -128 to 127

unsigned char
Range: 0 to 255

You see what happened there? In order to accommodate negative values we had to give up half of our possible positive values.

Also, to make a further note on this, all data types except for char are signed by default (meaning they can hold negative and positive values). A char can be signed or unsigned depending on the compiler involved, this is because a char is usually used to hold characters (which are all positive numbers) – most of the time you’ll find a char is unsigned by default.

So enough fuss, lets get to some coding to show you how to use this new information. Load up CodeBlocks like you did the last tutorial, create a new project, and empty file (if you need help on that please look at the first C++ tutorial). Then, from memory if you can, try to code out the bare bones of your program:

#include

int main() {
return 0;
}

We are going to make a simple program that will hold your age, and your age in dog years (boring, yes, I know). So, we’ll use a short int for the person’s age, and a float for the average. Why didn’t I use a char for the person’s age? Well, this is related to what I briefly said about characters. When cout / printf, or other functions that print text to the screen see a char come across, they will print the corresponding character instead of the value. You can see what I mean by this example:

char X = 97 ;

std::cout << X;

Instead of printing 97 like you would want, it actually prints ‘a’. Again, char is sort of a special data type that is really meant for characters. Please note there are ways to force the program to print the value instead of a char, but we won’t get into that.

So, back to the program, we have an int and float. Lets put that into our program:

#include

int main() {
int Age = 0;
float AgeInDogYears = 0;

return 0;
}

Notice what’s going on here. We first declare our data type, then a name for our variable, and then give it an initial value. You can make the name of the variable whatever you want. For instance, I could have put:

int TimothysAge = 0;

Note that a variable name must begin with a character or underscore _, but after the first character it can contain numbers. These variable names are all valid:

int _Age;
int Age;
int Age1;
int aGE;

These variable names are not valid:

int 1Age;
int !Age;

So, now that we have our variables made, lets make them do something. Set the variable “Age” to your actual age. For me, I would do:

#include

int main() {
int Age = 23;
float AgeInDogYears = 0;

return 0;
}

Now, just like in school, we can also create equations and perform math. We know that a person’s age in Dog years is actually the person’s age divided by 7.

#include

int main() {
int Age = 23;
float AgeInDogYears = Age / 7;

return 0;
}

You see what I did there? I was able to use the Age variable and treat it like a number. So when our program comes to the AgeInDogYears line, it will look up the value of Age (23), and divide it by 7. Lets actually make this value print out now:

#include

int main() {
int Age = 23;
float AgeInDogYears = Age / 7;

std::cout << "My age in dog years: " << AgeInDogYears;

return 0;
}

Look at what we did with cout. First, we print out a normal string (like we did in the first tutorial), but then notice we used another double arrow << to also print out AgeInDogYears. When we use cout that mixes strings and variables, you have to use multiple << to separate the two. For example, these are valid ways to use cout:

std::cout << "Your age " << Age << " in dog years is " << AgeInDogYears;

These are wrong / invalid ways of using cout:

std::cout << "You are Age years old"; //Will actually say "Age" instead of printing the value of Age
std::cout << "You are " Age " years old"; //Syntax error
std::cout << "You are " + Age + " years old"; //Syntax error

Now, take our code above and compile it. You should see it print out the correct number (for me that number is 3). But notice something, even though we used a float to hold decimal numbers, our value is not showing decimal numbers (unless you age is exactly divisible by 7). My age in dog years should really be 3.28571. Look back at this line:

float AgeInDogYears = Age / 7;

Look at the number 7. When the system comes across hard-coded numbers in your program it treats them one of two ways, as integers or floating point numbers. The way it distinguinshes between them is if a decimal is used on the number of not:

Treated as integer
7

Treated as floating point
7.0

So, when our age in dog years is calculated, the decimal number is automatically dropped because 7 is treated like an integer. In any division operations, the denominator always determines the end data type. So, if the numerator is an integer value and the denominator is a floating point value, we’ll end up with a floating point value. But, if it was the other way around, with a floating point as the numerator and an integer as the denominator, we’d up with an integer. Example:

int X = 7.0 / 3; // Equals 2
int X = 7 / 3.0 // Equals 2.33333

So, lets modify our program to fix this floating point issue:

#include

int main() {
int Age = 23;
float AgeInDogYears = Age / 7.0;

std::cout << "My age in dog years: " << AgeInDogYears;

return 0;
}

I will end this tutorial on this final note. You can perform all mathematical operations on variables and hard-coded values. These operations are:

Multiplication
*

Division
/

Addition
+

Subtraction
-

You can also use parenthesis like in algebra to group operations:

int X = 5;
int Y = (X * X) * 5;

Play around with some equations and try to get used to them.

Congrats! We’ve successfully used variables. We’ll be using them a lot in up coming tutorials so try to get a firm grasp on how they are used, the subtle differences between them.

C++ Variables – Tutorial Files:
Win32: Zip

New WordPress Theme

Tim Jones — Sat, 16 Jan 2010 19:51:00 +0000

We’re trying out a new wordpress theme in hopes that more content can fit on a page. In addition, I have turned on nested comments, comment pagination, and I am moving a bunch of things around. Let me know what you like, dislike, or just plain hate.

Also, I encourage people to register for an account as well.

SDL Net – Part 2 (User Tutorial)

Tim Jones — Thu, 07 Jan 2010 12:01:30 +0000

The following user tutorial was created by Kahshoo-heem, for the purpose of expanding upon the SDLTutorials.com series, and expounding upon the use of SDL. This tutorial, though not purposely a part of the SDLTutorials.com or created for the series, may be a branch or addition to the series. Please read notes by the author for any additional code and/or framework used by the author. If you wish to submit your own tutorial to this site, please visit the “User Tutorials” page.

Once we have made our common library, it’s time to think on designing the game. Network games can have many architectures, but, normally, there are always at least two applications: a server and a client.

A server can be dedicated, like most online multiplayer games over the internet. But, in this case, the server will be playing too. To make things simpler, the server always will be “X”, and the player that starts the game, too. It’ll be responsible for waiting clients to connect, too.

At each player turn, the program sets the grid status, refreshes the screen, and sends a message to the other player. Receiving this message, the other player is now able to make valid inputs, as the first one can only exit or minimize his application.

At this point, we may have to create a state for the application: connected. Without it, one can start the game alone, and send messages to a person who is not online.

Now, let’s take a look at the messages the program has to make. As we said in the first tutorial, we will send only a byte, that corresponds to the ID of the grid cell clicked. So we have to modify our CNetMessage class, as this byte can be zero, and the program can take the message as an empty string. Therefore, we will make the class CNetMessageApp. Here is the header file, CNetApp.h:

#include "CNet.h"

class CNetMessageApp : public CNetMessage {

private:

//Virtual function that indicates how many bytes may have to be loaded onto the object. Overrides the parent class function member to work with only a byte

virtual int NumToLoad();

//Virtual function that indicates how many bytes may have to be downloaded from the object. Overrides the parent class function member to work with only a byte

virtual int NumToUnLoad();

public:

//Function simpler than LoadBytes(), inherited from the parent class, as it only works with one byte

void LoadByte(char);

//Function simpler than UnLoadBytes(), inherited from the parent class, as it only works with one byte

char UnLoadByte();

};

Here comes the implementation, at CNetApp.cpp:

#include "CNetApp.h"

int CNetMessageApp::NumToLoad(){

if (state == EMPTY)

return 1;

else

return 0;

}

int CNetMessageApp::NumToUnLoad() {

if (state == FULL)

return 1;

else

return 0;

}

void CNetMessageApp::LoadByte(char ID) {

charbuf c;

c[0] = ID;

LoadBytes(c, 1);

finish();

}

char CNetMessageApp::UnLoadByte() {

charbuf c;

UnLoadBytes (c);

return c[0];

}

As we can see, very simple. Finally, we can modify the original files of Tim’s TIC TAC TOE game.

At the header file CApp.h, in the client side, we will have to add the following lines:

//adding the network library

#include "CNetApp.h"

private:

// Network status indicator

bool Connected;

// Network objects

CClientSocket* tcpclient;

CIpAddress* remoteip;

CNetMessageApp msg;

And, in the server side, we don’t need the help of CIpAddress object, so it can be deleted. However, we have to add a tcp socket that looks for – or, better saying, listen to – clients:

//network objects

CHostSocket* tcplistener;

And we are able to get into the implementation code. Firstly, let’s set this members when creating Capp object. At CApp.cpp, in the server side, we’ll have to add these lines to the constructor:

tcplistener = NULL;

tcpclient = NULL;

Connected = false;

And, in the client side,

Connected = false;

tcpclient = NULL;

remoteip = NULL;

Now, let’s see CApp_Oninit.cpp. We may have only to create the objects above, except CNetMessage, that is created automatically by CApp. In the server side, the code of CApp::OnInit() will be added by these lines:

//Creating host socket

tcplistener = new CHostSocket (1234);

if (!tcplistener->Ok())

exit(EXIT_FAILURE);

//Creating client socket

tcpclient = new CClientSocket();

And in the client side,

//Creating Ip and Socket objects

tcpclient = new CClientSocket ();

remoteip = new CIpAddress ("192.168.0.102", 1234);

Note that the client, in this example, will communicate with a determined machine. In my home network, “192.168.0.102″ will be the server’s address, and “1234″ will be the port we have chosen to use. Otherwise, in a LAN, there is a manner to broadcast a required connection, but this method uses UDP sockets. Thus, someone can use this kind of protocol to get the server address, and, after that, work with TCP sockets to make reliable and simple communication over the network.

On the other hand, that is the code on CApp_OnCleanup – it will destroy these objects:

Server side:

delete tcplistener;

delete tcpclient;

Client side:

delete remoteip;

delete tcpclient;

Now, we can examine what happens when we click the mouse in our application. At CApp::OnLButtonDown() we’ll change these lines:

if(CurrentPlayer == 0) {
SetCell(ID, GRID_TYPE_X);
CurrentPlayer = 1;
}else{
SetCell(ID, GRID_TYPE_O);
CurrentPlayer = 0;
}
}

to these:

CApp_OnEvent – Server side:

//Only starts to play once connected

if (Connected) {

//Player == 0 will always be Server. Always starts to play and always be "X"

if(CurrentPlayer == 0) {

SetCell(ID, GRID_TYPE_X);

CurrentPlayer = 1;

//Send a message to the client, telling the ID of the clicked cell

msg.LoadByte((char) ID);

tcpclient->Send(msg);

}

CApp_OnEvent – Client side:

//Player == 0 will always be Server. Always starts to play and always be "X". So if

//CurrentPlayer is not zero, the game is necessarily connected

if(CurrentPlayer != 0) {

SetCell(ID, GRID_TYPE_O);

CurrentPlayer = 0;

//Send a message to the server, telling the ID of the clicked cell

msg.LoadByte((char) ID);

tcpclient->Send(msg);

}

As we can see, no much changes have been made. If it’s not the application’s turn, it does nothing. If it is, the application sets the grid and player status, like it did priorly, and sends a message to the remote application. There’s no need to modify the rendering behavior.

Lastly, we have to write CApp OnLoop() member function. We have to do two things: try to connect, or, if yet connected, receive the messages sent over the network. Below, the code of CApp_OnLoop.cpp, server side:

#include "CApp.h"

void CApp::OnLoop() {

//if not connected, listen to the port to detect if there is a client waiting there

if (!Connected) {

if (tcplistener->Accept (*tcpclient)) {

Connected = true;

}

else {

//if connected, checks the socket for messages ready to be read

if (tcpclient->Ready()) {

// if there is a message, try to receive it. In case of disconnection, the TCP protocol sends

// a message with no bytes

if (tcpclient->Receive (msg)) {

//if there is a valid message, we can set the grid and player status

SetCell((int) msg.UnLoadByte(), GRID_TYPE_O);

CurrentPlayer = 0;

}

else

Connected = false;

}

The commented lines say by themselves the program’s flow. On the other side, the client’s code:

//if not connected, try to connect to the server

if (!Connected) {

if (tcpclient->Connect(*remoteip)) {

if (tcpclient->Ok()) {

Connected = true;

}

else {

//if connected, checks the socket for messages ready to be read

if (tcpclient->Ready()){

// if there is a message, try to receive it. In case of disconnection, the TCP protocol sends

// a message with no bytes

if (tcpclient->Receive (msg)) {

//if there is a valid message, we can set the grid and player status

SetCell((int) msg.UnLoadByte(), GRID_TYPE_X);

CurrentPlayer = 1;

}

else {

Connected = false;

}

Then we have reached the end of this tutorial. I hope you enjoyed it, and feel free to use and modify the library shown here.

SDL Net Tutorial Files:
sdl-net-clientfiles.tar
sdl-net-commonfiles.tar
sdl-net-serverfiles.tar

Just to check up…

Tim Jones — Wed, 24 Jun 2009 11:12:04 +0000

So, how is everyone doing so far in the contest? Run into any problems?

Note: There is a poll embedded within this post, please visit the site to participate in this post's poll.

Some inspiration again:

Contest | Resources

Tim Jones — Thu, 11 Jun 2009 11:54:16 +0000

As a helpful gesture to all you out there that may need some resources (sounds, music, art), visit the link below:

http://forums.sdltutorials.com/viewtopic.php?f=19&t=36

Contest | Prize increase

Tim Jones — Fri, 05 Jun 2009 15:42:17 +0000

The dollar prize has changed to: $200 (PayPal)

A special thanks to Sergey Tikhonov for the donation!

SDL 1.3

Tim Jones — Fri, 02 Jan 2009 13:41:30 +0000

It seems there has been a lot of improvement with SDL lately, and that it is nearing its next major release. Here’s an announcement made by Sam Lantinga recently:

SDL 1.3 is ready for a massive bug hunt!

http://www.libsdl.org/tmp/SDL-1.3.zip

or

http://www.libsdl.org/tmp/SDL-1.3.tar.gz

The first person to report any particular bug for SDL 1.3 in bugzilla (http://bugzilla.libsdl.org) will get their names added to the CREDITS list for the great SDL Bug Hunt of January 2009!

Anyone who contributes an SDL 1.3 bug fix which is accepted, regardless of whether they reported it, will have their names added to the CREDITS list as bug squashers in the great SDL Bug Hunt. The top three squashers will be featured on the SDL website with a link to their favorite project (if they want.)

When contributing a patch, please include permission for me to release your code with SDL 1.3 and future versions of SDL under both the LGPL and a closed-source commercial license.

Contributors to SDL 1.3 are eligible for a discount on commercial licensing. Please contact me for details if you’re interested.

See ya!
-Sam Lantinga, Founder and President, Galaxy Gameworks LLC

As such, after the official release all tutorials will get a makeover to reflect the changes in 1.3. Until then, I encourage everyone to continue to use SDL 1.2.x. Also, anyone interested in Commercial Games with SDL, should pay attention to this site now (http://galaxygameworks.com/). You’re still free to use the library as long as you dynamically link the library, but for static links, you need a commercial license now. One incentive to get a license is official iPhone/iPod support now.

C++ Tutorial Basics

Tim Jones — Fri, 05 Dec 2008 18:01:43 +0000

Okay, so you are here. You’ve decided, hey, I want to start making games. Good idea! I certainly encourage you in your mission, but lets face facts. Making games is hard. Really hard. And not to throw unscientific percentages at you, but practically 90% of all those wanting to make games never finish anything. There are always two reasons, lack of discipline, or lack of understanding. You hit a wall, try to find the easiest way around, and then give up for the next project. Or, you get tired of the game you are working on, think of a “better” idea, and then start on that. Games are subjective, tastes change, and along with helping you on the way to programming, I also hope I can give you some discipline to finish your work.

Now, here we are, at the very beginning of it all. Don’t worry, before you know it you’ll be making games in no time. Don’t rush yourself. Believe me, once you know how to program, you’ll miss all the learning (not that you won’t have more to learn). The journey is the most important part, and the most fun.

Some very very basics first. That thing in front of you, that’s a computer (okay, technically a monitor probably, but let’s not be picky). For all you know, it does stuff. You click, you open windows, you download music (hopefully legally), play games, talk to friends. That’s about all it has been so far. Then, you got the brilliant idea to make a game. Well, exactly what is a game? More pointedly, how does anything work on a computer?

As you may know, everything in the computer world is represented in binary, 0 and 1. Meaning, on or off, true or false, or whatever other representation you want. This poses a slight problem to human beings, we cannot figure out the right combination of 0s and 1s to do anything. Imagine putting billions upon billions of 0s and 1s to write a game – it’s impossible! So, “in the beginning”, nice nerd people developed languages. They were crude at first, getting simple things done. These were called low-level languages. They performed basic things, extremely well. They told the computer to store bits into memory, or to get them back out, and so on. Well, that worked for a while, and then things got more complex. Now, we have high-level languages. C++, happens to be one of those languages. So, we use C++ and a bunch of commands and such, and it gets converted into those nice 0s and 1s (please understand, I am being very basic here).

Now, in order to get your C++ code into binary, we use something called a compiler. This is a middle-man program that takes your code, and spits out a program. Click the program just like anything else, and hey, it works! Now, alongside this, is something called a linker. You see, linker and compiler work together, they’re brothers! Linker is nice, it lets you take Joe’s C++ code and combine it with your own code – this then is sent over to compiler. Beyond this, as a beginner, don’t worry about how it works right now. As you progress, and gain experience, you’ll learn more about how these two tools (and many other tools) actually work. But for now, understand code go in to compiler, program come out of compiler.

So what is code exactly? Well, it’s just text (basically). It’s like the text on this page, except it has a different meaning. Take, for example, this math equation:

X = 1 + 1

That can be seen as code. In itself, it doesn’t mean anything. But if given to something like a compiler, it can be a program!

Now, one important aspect is to have the right environment. First, we know, you need a compiler and a linker. And for beginners, you’ll need an IDE (technically, you could code in text editor if you wanted). Now, an IDE, or Integrated Development Environment, is basically a program where you code. But it comes with some nice features, like it comes with a compiler and linker, and sets it up for you! It also gives you a lot of other people’s code; most of which we’ll be using in these tutorials. Why use other people’s code? Because, believe me, if you started with a clean slate, you’d have to code even the ability to print a single pixel to the screen. So, first task! Go download CodeBlocks:

http://www.codeblocks.org

Important note: Download the most stable, and the one with mingw. I’ve had quite a few people download the one without (sigh). Once installed, and opened, you’re ready to continue.

Click File, and then New Project. On the window that opens, click Empty Project and then Go. For the project title, pick what you want. I am putting C++ Basics. For a folder, put whatever. Click Next. Check only the “Create ‘Release’ Configuration”. Click Finish. Now click, File and then New Empty File. On the window that pops up, be sure to add to your project. For the file name, put main.cpp. Copy this code below, and paste it in:

#include

int main() {
std::cout << "Hello World!\n";

return 0;
}

Click Build and then Build and run. If successful, you should see “Hello World!” followed by some other text. If so, congratutations! You just made your first program, sort of.

How lets explain what’s going here. First off at the very top, we have #include. Now would be a good time to explain the differences between two areas of your code. The first area is code to used by your compiler, the second area is your actual code to be made into a program. Anything that has a # before it, is code to be used by the compiler. Meaning, this code never actually makes it into the program. Why is this useful? Well, in this tutorial we have #include, this tells the compiler to include another file. In this case, we’re telling the compiler to go out and grab the file iostream and include it in the program. Another example would be #define.

#define MY_NAME "Tim"

std::cout << MY_NAME;

Now, wherever we put MY_NAME, it is replaced with “Tim.” This first area is called preprocessor directives. These “direct” the compiler before getting to the actual code. So, to explain the first line again, we’re including the file iostream into our program. The reason why we do that is because the code for std::cout is in there. And we need that.

Next, we have int main() { }. This is called a function, and while we won’t get into functions until later, I need to try to explain them briefly. First, whenever you first run your program, the operating system needs to know where your code begins. That’s what main() is for, that’s where your code begins. So, when you open your program, it starts at the top of main, and goes down line by line. When it reaches the end, it’s done, and your program stops. Now, the { } simply define ownership. Everything within the curly braces { } belongs to main. Secondly, main is also a function. A function is simply a group of code. So, for example, we might have:

int Group1() {
}

int Group2() {
}

int main() {
}

We have three functions, each with its own code. But there are some important things about functions. A function may return some data:

int MyAge() {
return 22;
}

In this case, the function MyAge returns 22. Meaning, when the function is done, it’ll give back the number 22 from wherever it was first called. So, when the operating system opens our program, and our function main returns 0, it’s giving the number 0 back to the operating system. Why do we return 0? Well, lets say something wen’t wrong with your program when loading, in that case we can return 1, and if everything is okay, we can return 0. Again, this is a very very basic explanation of functions, and there’s a lot more to them. Just understand that when your program first opens that it starts at the top of main.

Next, we have the actual magic, std::cout. Now, this is really hard to explain to beginners, but for all purposes std::cout is simply a way for you to print text. You can use the << to separate text as well. Like:

std::cout << "Hi " << "my " << "name " << "is " << "Tim.\n";

Here’s the things I want to get across though. Notice the ; at the end? This is important, this is your period, so to speak. It signals the end of your particular command/code. Notice the code below:

std::cout << "Test";
std::cout << "Test";
std::cout << "Test";

Each command is separated not by a newline, but by a semi-colon. For beginners this is important, don’t forget your semi-colons! (Notice the one on return too). So, what’s that \n funny thing? That’s a newline character, which basically says, hey, move down a line. Like pressing Enter in a text editor.

Well, that’s all for now. This tutorial was very basic, and was intended that way. Future tutorials will tackle harder subjects at an increasing rate.

Note: If your program opens and closes suddenly, run it from the command prompt. Start -> Run -> cmd. Navigate to your folder, and then type in your program. Hit enter!

C++ Basics – Tutorial Files:
Win32: Zip, Rar