First of all, you need to understand that C++ defines the concept of reference. A simple (lvalue) reference, is identified by an « & ». A reference is just a name for a thing. In other words, a reference defines a synonym for something :

Here, ra is a reference. Manipulating ra is the same as manipulating a. Those are two names for the same thing (a literal integer).

With that in mind, let’s now examine those two expressions :

With the second one, each time you send a QString to something, the QString is copied. Thus, this is in fact a copy of the QString that you manipulate inside the function. However, Qt implements what they call « Implicit Sharing » (an other name for « Copy On Write » pattern). Thus, the QString is not entirely copied. Instead datas are just shared among QString instances, until one tries to modify the QString, then a deep copy is made.

However, with the first one, no copy at all is needed. Instead, inside your something function, you are manipulating the same QString object. The reference being qualified as « const », you’re not able to modify this object, because it is in « read only ».

To sum up briefly, the second expression needs to perform a copy, where as the first doesn’t (then the first is better, even with implicit sharing, which is not free).

Here the QString object is also a reference. However, this is not const. If you try to do something like this :

But then you can expect something to have some side effects, like modifying your QString object.

const here is not really useful, since the string object is a copy. If just may be useful if you want the compiler to raise an error if you try modifying the string object.

So, in C++, to avoid useless copies when passing parameters into function, we use references (identified by an « & »). Generally, those references are const-qualified, to tell the compiler « Hey, I won’t modify this object ». Furthermore, const-reference are able to be bound to temporary objects (like I said before).

In addition, you should keep in mind that C++ uses the & as reference operator to retrieve the address of an object in memory as well.

So the meaning of & is a bit different dependig whether used with types or variables.

octal wrote:

lvalue

can you explain to me this term?

the literal string “Hello” (which is of type const char[ 6 ]) will result in a temporary (rvalue)

Are you sure that hello is a const char⁶???

This doesn’t give an ouput.I am almost sure that in c++ arrays count from zero so 5 is 4.

Lukas Geyer wrote:

So the meaning of & is a bit different dependig whether used with types or variables.

correct?

Moreover,

In this situation why the pointer is valid?
Is this because of the usage of the ampersand?

In conclusion,after a little search,i found a good article and i understand the reference mechanism.

So the reference is being used in order to avoid copying(making slower) our application.

Is there any reason,for which i should use the reference mech in my functions?

thank you for your help :)

can you explain to me this term?

an lvalue refers to an expression that has a name and persists in memory, as opposite to rvalue which refers to a temporary.

Are you sure that hello is a const char6???
1
2
const char[] hello = “hello”;
qDebug() << hello⁶;
This doesn’t give an ouput.I am almost sure that in c++ arrays count from zero so 5 is 4.

Yes in fact, this is « const char[ 5 ] ». But I meant the type of “hello” is « const char[ 5 ] », my bad.

EDIT: erf, I was right, you have a final ‘\0’, so this is const char[ 6 ].

I don’t understand what you’re trying to achieve here.

Is there any reason,for which i should use the reference mech in my functions?

anytime you don’t need useless copies.

Anyway, I think you need to take a C++ course before going on with Qt. You can look at the wiki for some good books :)

octal wrote:

bq. can you explain to me this term? Yes in fact, this is « const char[ 5 ] ». But I meant the type of “hello” is « const char[ 5 ] »

I can produce an output with const char [5] only with 4 or less.

1. //it is used in variables
2. QObject obj;
3. QWidget wid = &obj;

I don’t understand what you’re trying to achieve here.

I am trying to tell you if understand correctly when the reference is used for memory and when it doesn’t.

Now, If you want to save the copying time, memory, and also don’t want to change the original value, just put ‘const’

And when you ‘call by value’ ,

The errors you got , probably because of something in the declaration part, i suppose.
……………………………………………………………………

Interestingly, foreach keyword has something to tell. :) It is a macro and is implemented using the preprocessor. You should go through the docs [doc.qt.nokia.com].

And i think,here again same laws as above.. [ copy / dont copy ]

EDIT 2:
NOTE : Its clear in the document
Qt automatically takes a copy of the container when it enters a foreach loop. If you modify the container as you are iterating, that won’t affect the loop. (If you do not modify the container, the copy still takes place, but thanks to implicit sharing copying a container is very fast.)

Since foreach creates a copy of the container, using a non-const reference for the variable does not allow you to modify the original container. It only affects the copy, which is probably not what you want.

Giorgos Tsiapaliwkas wrote:

the literal string “Hello” (which is of type const char[ 6 ]) will result in a temporary (rvalue)

Are you sure that hello is a const char⁶???

1. const char[] hello = "hello";
2. qDebug() << hello[6];

This doesn’t give an ouput.I am almost sure that in c++ arrays count from zero so 5 is 4.

There is a difference between char[] as a type and char[] as an index access.

• const char[] hello = “hello” reserves a consecutive block of memory which stores the characters of the word “hello” at position 0 – 4 and a trailing ‘\0’ at position 5 which terminates strings in C++.
• hello[ 6 ] returns the character stored at position 6 in this consecutive block of memory. Obviously there is none, because the positions range from 0 to 5. Thus you get no output.

Giorgos Tsiapaliwkas wrote:

Lukas Geyer wrote:

So the meaning of & is a bit different dependig whether used with types or variables.

1. //it is used in variables
2. QObject obj;
3. QWidget wid = &obj;
4.  
5. //it is used in types
6.  
7. something(const QString &string);

correct?

The idea is right, the code is wrong. The reference operator returns the address of an object, not an object. This address has to be stored in a variable of type “pointer to object”, not “object”. Take another look at the code I’ve posted.

In addition, the pointer has to be of the same type as the object. Otherwise you will have to do an explicit type conversion using a cast (or this is done for you implicitly, as for example in inheritance hierarchies).

Giorgos Tsiapaliwkas wrote:

Moreover,

1. void startJob(Job &work){
2. .....
3. delete &work;}
4.  
5. void doJob(){
6. Job *doing = new Job;
7. startJob(doing);}
8. //no compiler error

In this situation why the pointer is valid?
Is this because of the usage of the ampersand?

I don’t think this code compiles.

startJob(Job& work) expects an parameter of type Job, whereas the parameter you pass doing is of type pointer to Job (Job*). That’s two different things, two different types.

Lukas Geyer wrote:

I don’t think this code compiles.

Yes you have right.The code that compiles is this one,

thanks you all of you for help and for your time.

I will mark the thread as solved.

thanks

Sorry for that comment, Giorgos, but reading this code make me nervous:

A reference means you get a reference to an object, but that could be loacted on the stack, the heap or even anywhere else (a const ref also in code segment). If you want to delete some memory by it, I would prefer using pointers as parameters´.

I would prefer here:

Gerolf wrote:

Sorry for that comment, Giorgos, but reading this code make me nervous:

no problem.Comments are more than welcome :)

this code is not writen by me.Its just a code that i came across.

I would prefer here:

@
void startJob(Job* work)
{ ….. delete work;
}
@

So do I.:)

thank you for your comment

Welcome.

The point why I wrote that comment is, that a pointer can be invalid (which is typically 0), a reference should never be invalid. It should always reference a valid object.