Thread: Some questions

In the function "void foo(const int)", what does the const do? I get how it is usefull if the value is passed as a reference, but when its not i dont understand what the const do.

It serves as a reminder to the implementer of foo() that the parameter is not to be modified. To the caller it does not matter.

Is there a difference between void foo(int *a) and void foo(int &a)?

Of course. For the former a is a pointer to an int, for the latter a is an int reference.

At university, they teach us to always make all class variables private. Is this really a good idea? I see that is is useful is some cases (say, addMoney() to change the balance a bank account class).

They probably also talked about encapsulation and data hiding. Look up your notes for these concepts. That said, in some cases we could have a POD struct consisting entirely of public member variables. This would serve purely as a way of grouping some data.

How can you make a function that turns 1 into 0 and 0 into 1? Without using if statements.

With mathematics

Originally Posted by h3ro

In the function "void foo(const int)", what does the const do? I get how it is usefull if the value is passed as a reference, but when its not i dont understand what the const do.

Const itself tells the compiler that the data in this variable will not be modified, so you can understand how useful it is when using references... with a pass-by-value, it's rarely useful at all. But you can apply const to the whole function as well, which might be useful.

Is there a difference between void foo(int *a) and void foo(int &a)?

Although very similar, the biggest difference between references and pointers (when it comes to arguments) is that the syntax differs a bit.

At university, they teach us to always make all class variables private. Is this really a good idea? I see that is is useful is some cases (say, addMoney() to change the balance a bank account class).

It's certainly a good idea to make most member data private, but sometimes it's not such a bad idea to make some public.

A const in a function parameter can also indicate to the compiler better if it can optimize the function when inlining - although it can probably figure that out with flow-analysis.

The difference between a pointer and a reference is small when it comes to the actual implementation in the compiler, but it's syntactically different, and it has slightly different meaning in the code - but the effect is very similar.

Encapsulating the data (making it private) is a good way to ensure that you can change the internal data storage without changing the code that calls a function. Say you store some data in an array, and just let the code access the array directly. Then you find that you have a BIG performance problem, where a customer is getting 15 minute waiting times on the application, which is no good. So you have to re-organize the data into a binary tree, the usage time is now down to 5 seconds, brilliant. Simple change of the internal data structure, except all the places where you have to change the code that accesses the array directly, in two dozen different source files. If you hide all the data from the client software, then you can store the data in any way you like - even on a different computer via a database mechanism for example.

There is of course a compromise between hiding the data and the overhead that implies, and the efficiency of accessing the data directly in the application. It will be the judgment of the implementor to decide which is more important, and where you should use data hiding/ecnapsulation, and where you should expose the data to the client software. A typical example where data hiding is not necessary would be a coordinate vector class for 3D graphics - there are only a few different ways you'd ever want to do that, so you may just as well expose the "float x, y, z" to the client software, rather than have the overhead of getting a "getx, gety, getz" function members. Of course, if you then want to do SSE/3DNow! optimisations on the data-flow, you'd struggle, becasue you actually want a vector of x, another vector of y and a third vector of z values, so that it is easy to do 2 or 4 math operations of the same type at once.

--
Mats

Oh, and your last question is simple:

Code:

int func(int x)
{
     return !x;
}

By the way, if you want to make sure a value is either 0 or 1 as a truth value, then

Code:

int func(int x)
{
   return !!x;
}

This will guarantee that the truth-value is the same (so passing in 4 will return 1, whilst passing in 0 will return 0).

--
Mats