Thread: confused about variables

1 Byte = 8bits
2 Bytes = 16bits

a character such as 'a' is 8 bits (1 byte)
2 characters = 2 bytes (16 bits)

an integer (a number) = 4 bits

so say you have a variable

char a;

a can store 1 character byte

where as if you have

char a[2];

a has an array of 2 bytes a[3] has an array of 3 bytes and so on

int is a variable that can hold whole numbers only. No decimals. I can't remember it's restrictions, but it's far more than 2 digits.

int a = 1300086

double w = 12.56

valid variable declarations

i edited my last post, read up

The C++ standard specifies the minimum capacity for each type. A type-char must hold at least one byte, but on a 32-bit system it might be 4-bytes.

A byte is 8 bits (binary digits). This is computer jargon. There is not type "byte" in C++ ... "byte" is not part of the C++ language! With 8 bits, the maximum count is 11111111 binary, which equals 255 decimal. With two bytes, you can count up to 65535.

In order to keep your code standard-compliant (and portable) you should not store a number greater than 255 in a type-char... even if your system can handle it!


A single variable can hold a single number. That number may represent a single ASCII character.

To store a word or sentence, you need an array of characters. This is called a string variable.

Character arrays are sometimes called C-style strings. (C++ also has a string class which is used to create string objects.)

Here are the minimim capacities for each type:

char -128 to +127 (1 byte)
unsigned char 0 to 255 (1 byte)

int -32,768 to +32,767 (2 bytes)
unsigned int 0 to 65535 (2 bytes)

long -2,147,483,648 to +2,147,438,647 (4 bytes)
unsigned long 0 to 7,294,967,295 (4 bytes)

float +/- 2.1E-38 to +/- 3.4 E38 (4 bytes)
double +/- 2.2E-308 to +/- 1.8 E308 (8 bytes)

Additionally, there are certain relations that must hold between the sizes of built in types.
Along the lines of: sizeof(short) <= sizeof(int) <= sizeof(long), etc (you get the idea).

Now that you know what a variable is I'll explain what a function is.
Imagine a simple math equation

Code:

f(x) = x^2+1
g(x,y) = x/y

For several values of x and y you have

Code:

f(2) = 2^2+1 = 5
f(10) = 10^2+1 = 101
g(4,5) = 4/5 = 0.8
g(0,7) = 0/7 = 0

For diferent values of x and y you have diferent results. Note that all functions return only ONE value.
Now using C notation, it the exact same thinking, with a diference: you have to write the type of your input variables like this

Code:

f(int x){
// do something and return x^2+1
}
g(int x,int y){
// do something and return  = x/y
}

But you may note there's something missing here, which is the return type of the result. Any function can return a integer, a char, a floating point number, a pointer... whatever. So to point out this, one MUST specify always a return type for a function.
So

Code:

int f(int x){
// do something and return x^2+1
}
float g(int x,int y){
// do something and return  = x/y
}

This way f and g are functions that calculate something using integers and return a single result.
And to finish what does one need to write to point that the function should return something?
A return statement:

Code:

return expression;

So

Code:

int f(int x){
// do something and return x^2+1
   return x*x + 2;
}
float g(int x,int y){
// do something and return  = x/y
    return x/y;
}

Whenever a return statement is reached your function execution ends and the result of the expression in the return statement is returned.
But what if y is 0 ?? Division by zero isn't allowed. So using the return statement:

Code:

float g(int x,int y){
// do something and return  = x/y
    if(y == 0)
        return 0;
    else
        return x/(float)y;
}

And to finish why "x/(float)y" and not "x/y" ?
x and y are integers so division between them 2 will result in a integer division or by other words, only the quocient is returned and the remainder is dispised. To get the remainder use % instead.
e.g.

Code:

2/3 = 0		2%3 = 2
5/4= 1		5%4 = 1
13/11 = 1	13%11 = 2

But we want it to return a complete floating point value, including the divided remainder.
So after casting y ( "(float)y" ) , having therefore a float variable, the division will result in a floating point value.

Code:

2/(float)3 = 0.66666...
5/(float)4= 1.25
13/(float)11 = 1,1818...

//Or if you declare implicit floats
2/3.0 = 0.66666...
5/4.0 = 1.25
13/11.0 = 1,1818...

So your g function receives 2 ints and calculates the division between them and returns it in floating point format.

Also type void is allowed for functions return value. Or in other word use void for function that don't return anything.

Code:

void give_grandma_a_cake(){//no parameters
    go_to_grandmas_house();
    give_the_cake();
    run_from_scary_wolf();
}

int main(){
/*****
    This expression is invalid because the function
    doesn't return anything

    int result =  give_grandma_a_cake();
*****/

    //now this is valid because there's no return value
    //and therefore nothing to assign no any variable
    give_grandma_a_cake();

    return 0;//return 0 to the operation system ;)
}

The contrary is also valid. One doesn't need to send input variables to get a different result every time. A example of that is the rand() function which returns a different random value each time it is called.

Code:

int r1 = rand();
int r2 = rand();
int r3 = rand();

r1, r2, and r3 have different values... or may have, but that's another story.