Printable View
hi all~
i read this in a book which showed me an example with const reference in template:
it didnt mention the advantages using const reference here, any ideas ?Code:template <class T>
T Abc(const T& a, const T& b, const T& c)
{
return a + b + b * c + (a + b - c) / (a + b) + 4;
}
thanx~
if T is an int there is no advantage, if it's a short or char a less agressive compiler might even be a bit slower, but if T was a 2000 X 2000 matrix then the reference saves you three very big copy operations. const references can also be bound to temporaries, thus,
Code:void center(const std::string &s, int col=80) {
int padding = (col - s.length() )/2;
for(int i=0;i<padding;++i) std::cout << ' ';
std::cout << s;
}
std::string hi="hello";
center(hi); // no copy of hi made
center(std::string("A String")); // temporary created, used, discarded
center("this also works"); // the compiler will create a temp here automatically.
thanx i know reference can run faster, but what really confused me is the meaning of "const reference", and what is the difference between reference and const reference here ?
thanx~
I'm guessing a const reference stops you from changing the value of the variable. Ie:
However I may be wrong.Code:int a=5;
int &b=a;
b=7; //not allowed
thanx bennyandthejetsQuote:
Originally Posted by bennyandthejets
if follows you then these two will be same because parameters not changed:
and i think there may be other usage for const reference, perhaps it can help for better performance than simple reference ?Code:template <class T>
T Abc(const T& a, const T& b, const T& c)
{
return a + b + b * c + (a + b - c) / (a + b) + 4;
}
template <class T>
T Abc(T& a, T& b, T& c)
{
return a + b + b * c + (a + b - c) / (a + b) + 4;
}
In general 'const' does not affect performance. Rather, it enforces good programming techniques.
bennyandthejets are right and a const reference can only invoke const member-functions. As for your two code-snippet comparisment you are right. The code doesnīt differ (except for the const-ness of course), but the compiler cannīt analyse (yet, and I think itīs part of the standard) the code and know if the object state is changing. In this case anyone can see that the const are unneccesary (but as bennyandthejets pointed out "it enforces good programming techniques", better learn it now) but as code can get very complex this might not be as easy. And because compiler are consistent the rule aplies for non-complex and complex code. Have you ever considered why an array have to have a constant expression?
Why does it generate a compiler error? Well it demostrates the same "problem" you encountered. How should the compiler know if you deside to change value on arraySize?Code:...
int arraySize = 5;
int array[arraySize];
...
Only through heavy code-analysis and if the code is very complex this might not be as easy. Consistent is the key word here.Code:...
if (flagon)
arraySize = 10;
...
int array[arraySize];