Question

I have some questions about C++ from a C# developer.

For a few days I have been looking at some C++ code, and I have the following questions:

1. When do use Foo::, Foo. and Foo-> ?
2. When do I use a real constructor and when just String a; (sometimes I need to do something like String a("foo");)
3. What is the difference between these signatures: int foo(int a) and int foo(int &a)?

Answer 1

:: is used either to explicitly specify a namespace (std::string, for example, for the string class in the namespace std), or for static members of a class.

. is used much as in C#, to refer to a member of a class.

-> is used with pointers. If p is a pointer to an object obj, then p->x has the same meaning as obj.x.

when do i use a real constructor and when just String a; (sometimes i need to do something like String a(“foo”);)

When you need to. String a is roughly equivalent to C#’s a = new String() (with the caveat that if String is a non-POD type, it may contain uninitialized members.)

If you need a initialized to a specific value, you do that. (either with String a("foo"), or with String a = "foo")

where is the difference between these signatures: int foo(int a) and int foo(int &a)?

The & denotes a reference. It’s not quite a C# reference, but there are similarities. In C#, you have value types and reference types, and reference types are always passed by reference.

In C++, there’s no such distinction. Every type can be passed by value or by reference. The type T& is a reference to T. In other words, given the following code:

void foo(int& j);
void bar(int j);

int i = 42;

foo(i);
bar(i);

foo will get a reference to i, which means it it can modify the value of i.
bar will get a copy of i, which means that any modifications it makes will not be reflected in i.

You often use const T& (a reference to const T) as a way to avoid the copy, while still preventing the callee from modifying the object.