Thread: Simple Calculator

Code:

while( professor == useless ) {
   replace( professor );
}

He wants you to do this but hasn't taught you about pointers yet? Yeesh.

the "float *z" part in your function declarations say that the function takes a pointer to a float as its argument. A pointer is the address of a something in memory. So you've got a float called "z", it's stored some address in memory, and the function expects you to tell it that address. You would normally call the function this way:

Code:

void_conjugate( &x );

where the &x means, give us the address of x. A pointer to x is passed to the function.

Now, you're storing your complex numbers as two-element arrays. An array is a sequence of objects in consecutive addresses in memory. So z[1] is stored directly after z[0] in memory. Referring to just z without brackets gives you the address of the array, which is the address of its first element- so "z" and "&z[0]" are the same thing.

You can therefore call conj_complex this way: "conj_complex( z );"

I hope this helps. Let me know if it's still obscure.

Okay, let's go for a simple example. Suppose your computer's memory contains only ten memory locations. Now do the following:

Code:

int x = 50;

Your variable "x" will be stored somewhere in memory as follows:

Code:

Address: 1   2   3   4   5   6   7   8   9   10
Value:   ?   ?   50  ?   ?   ?   ?   ?   ?   ?

This means the computer has stored the 50 at memory address 3.

If you now do

Code:

int *a = &x;

This declares a variable of type "pointer to int" whose value is the address of the variable "x". Its value is 3, because that is where "x" is stored in memory.


Now write a new program as follows:

Code:

int array[4] = {0,10,20,30};

Your memory might look like this

Code:

Address: 1   2   3   4   5   6   7   8   9   10
Value:   ?   ?   ?   ?   ?   ?   0   10  20  30

So the following are true:
&array[0] is equal to 7
&array[1] is equal to 8
&array[2] is equal to 9
&array[3] is equal to 10
array is equal to 7, because it is the same thing as &array[0].

And all of these 5 things are pointers that can be passed to functions that expect an "int *" as an argument.

You won't need to create new pointers- remember that the name of the array already is a pointer. So if I wanted to write a function that takes a complex number "a+bi" and changes it to "b+ai" I would do this

Code:

void swap_complex( int *q ) {
   int temp = q[0];
   q[0] = q[1];
   q[1] = temp;
   return;
}

and call it like this:

Code:

int main( void ) {
   int z[2] = {1,5};
   swap_complex( z );
   return 0;
}