const-reference

I really admire java features and I don't want to give up using it for the next problem: I have a class that might be inherited, and inside of it is a private ArrayList arr; So the setter function is ok , but the getter function return arr; returns the reference to that variable which anyone capable of editing that whole array which I don't want and private wouldn't make any sense ! In C++ I would just return const arr; and it would return constant reference to the variable. I so much need the variable not to be cloned or manually copied because there are so many calculations that require to

I'm using Visual Studio Express 2013 and is fooling around a bit trying to learn about different things in C++. I stumbled upon an interesting bug in the compiler where it doesn't seem to create a temporary object when explicitly type casting to the same type as the reference. #include <iostream> using namespace std; int main() { int number; // float number; number = 2; const int& plainref_i = number; const int& recastref_i = (int)number; // this goes wrong if number is int const float& plainref_f = number; const float& recastref_f = (float)number; // this goes wrong if number is float number

I'm aware of the fact that assigning an rvalue to a const lvalue reference extends the temporaries lifetime until the end of the scope. However, it is not clear to me when to use this and when to rely on the return value optimization. LargeObject lofactory( ... ) { // construct a LargeObject in a way that is OK for RVO/NRVO } int main() { const LargeObject& mylo1 = lofactory( ... ); // using const& LargeObject mylo2 = lofactory( ... ); // same as above because of RVO/NRVO ? } According to Scot Meyers' More Effective C++ (Item 20) the second method could be optimized by the compiler to

Can you explain to me the difference between returning value, reference to value, and const reference to value? Value: Vector2D operator += (const Vector2D& vector) { this->x += vector.x; this->y += vector.y; return *this; } Not-const reference: Vector2D& operator += (const Vector2D& vector) { this->x += vector.x; this->y += vector.y; return *this; } Const reference: const Vector2D& operator += (const Vector2D& vector) { this->x += vector.x; this->y += vector.y; return *this; } What is the benefit of this? I understand the sense behind const reference passing to function as you want to make

Some time ago I was confused by the following behavior of some code when I wanted to write a is_callable<F, Args...> trait. Overload resolution won't call functions accepting arguments by non-const ref, right? Why doesn't it reject in the following because the constructor wants a Test& ? I expected it to take f(int) ! struct Test { Test() { } // I want Test not be copyable from rvalues! Test(Test&) { } // But it's convertible to int operator int() { return 0; } }; void f(int) { } void f(Test) { } struct WorksFine { }; struct Slurper { Slurper(WorksFine&) { } }; struct Eater { Eater(WorksFine)

struct A { A(int) : i(new int(783)) { std::cout << "a ctor" << std::endl; } A(const A& other) : i(new int(*(other.i))) { std::cout << "a copy ctor" << std::endl; } ~A() { std::cout << "a dtor" << std::endl; delete i; } void get() { std::cout << *i << std::endl; } private: int* i; }; const A& foo() { return A(32); } const A& foo_2() { return 6; } int main() { A a = foo(); a.get(); } I know, returning references to local values is bad. But, on the other hand, const reference should extend a temporary object lifetime. This code produce an UB output. So no life extention. Why? I mean can someone

There are sort of two related questions here: A) How is enum implemented? For example, if I have the code: enum myType { TYPE_1, TYPE_2 }; What is actually happening? I know that you can treat TYPE_1 and TYPE_2 as ints, but are they actually just ints? B) Based on that information, assuming that the enum passed in didn't need to be changed, would it make more sense to pass myType into a function as a value or as a const reference? For example, which is the better choice: void myFunction(myType x){ // some stuff } or void myFunction(const myType& x) { // some stuff } Speed wise it almost

template<typename T> void f(T a, const T& b) { ++a; // ok ++b; // also ok! } template<typename T> void g(T n) { f<T>(n, n); } int main() { int n{}; g<int&>(n); } Please note: b is of const T& and ++b is ok! Why is const T& not sure to be const? NathanOliver Welcome to const and reference collapsing . When you have const T& , the reference gets applied to T , and so does the const . You call g like g<int&>(n); so you have specified that T is a int& . When we apply a reference to an lvalue reference, the two references collapse to a single one, so int& & becomes just int& . Then we get to the