I started to learn C++ for work, and it's been "fun". One of the first things I learned is passing function arguments by reference, instead of by value (or by passing a raw pointer). You can also return references, but I haven't seen this covered explicitly, so I wrote a small program to test things out. Here is a first version.
Gadgets
struct Gadget {
// members
int giovanni;
int giorgio;
// constructor
Gadget(int giov, int gior): giovanni(giov), giorgio(gior) {}
// a convenient method
void tellMe() {
cout << "giovanni: " << giovanni << ", " << &giovanni << "\n";
cout << "giorgio: " << giorgio << ", " << &giorgio << "\n";
}
};
int main() {
Gadget g{-3,7};
cout << "Defined a new Gadget g at " << &g << "\n";
g.tellMe();
}
(I'm using struct here, and class later, for no good reason)
Running it spits out something like this.
Defined a new Gadget g at 0x7ffee700d918
giovanni: -3, 0x7ffee700d918
giorgio: 7, 0x7ffee700d91c
Interestingly, the address of g is the same as the one for g.giovanni. This is probably C++ being smart about memory. This seems to be ok. While the lines below are fine
Gadget* p = &g;
(*p).tellMe();
the compiler will complain if we try this
Gadget* p = &(g.giovanni); // incompatible types
or this
int* p = &(g.giovanni);
(*p).tellMe(); // *p does not have a tellme method
Widgets
Let's add a second class (this time a class with everything explicitly public).
class Widget {
public:
// members
int myInto;
Gadget myGadget;
// constructor
Widget(int giov, int gior, int myo): myGadget(giov, gior), myInto(myo) {}
// info
void tellMe() {
cout << "myInto: " << myInto << ", " << &myInto << "\n";
myGadget.tellMe();}
// getters: by value, by reference
Gadget getGadget_val() {return myGadget;}
Gadget& getGadget_ref() {return myGadget;}
};
Let's write a main to use this.
int main() {
Widget w{2,-3,77};
cout << "defined new widget w at " << &w << "\n";
w.tellMe();
cout << "\ncalling tellMe from w.getGadget_ref()\n";
w.getGadget_ref().tellMe();
cout << "\ncalling tellMe from w.getGadget_val()\n";
w.getGadget_val().tellMe();
}
Running this will output something like this
defined new widget w at 0x7ffeec970910
myInto: 77, 0x7ffeec970910
giovanni: 2, 0x7ffeec970914
giorgio: -3, 0x7ffeec970918
calling tellMe from w.getGadget_ref()
giovanni: 2, 0x7ffeec970914
giorgio: -3, 0x7ffeec970918
calling tellMe from w.getGadget_val()
giovanni: 2, 0x7ffeec970908
giorgio: -3, 0x7ffeec97090c
and we see that indeed the members of w.getGadget_val() have different memory addresses.
Sanity check
As confirmation, let's try modifying getGadget_val() and getGadget_ref(). Here's a complete snippet.
#include <iostream>
using std::cout;
struct Gadget {
// members
int giovanni;
int giorgio;
// constructor
Gadget(int giov, int gior): giovanni(giov), giorgio(gior) {}
// a convenient method
void tellMe() {
cout << "giovanni: " << giovanni << ", " << &giovanni << "\n";
cout << "giorgio: " << giorgio << ", " << &giorgio << "\n\n";
}
};
class Widget {
public:
// members
int myInto;
Gadget myGadget;
// constructor
Widget(int giov, int gior, int myo): myGadget(giov, gior), myInto(myo) {}
// info
void tellMe() {
cout << "myInto: " << myInto << ", " << &myInto << "\n";
myGadget.tellMe();}
// getters: by value, by reference
Gadget getGadget_val() {return myGadget;}
Gadget& getGadget_ref() {return myGadget;}
};
int main() {
Widget w{2,-3,77};
cout << "defined new widget w at " << &w << "\n";
w.tellMe();
Gadget g1 = w.getGadget_ref();
g1.giovanni--;
w.tellMe();
// does not change w: g1 is a copy of w.myGadget!!
Gadget& g2 = w.getGadget_ref();
g2.giovanni--;
w.tellMe();
// works: notice when we create g2 we use Gadget&
Gadget g3 = w.getGadget_val();
g3.giovanni--;
w.tellMe();
// does not change w, as expected
// Gadget& g4 = w.getGadget_val();
// does not even compile, as RHS is temp
}
This all makes sense, however the difference between g1 and g2 is subtle: it's only in the type we use. We could easily make that mistake and copy something without noticing (or viceversa). What if we don't want to allow copies? Or references? For this we can tinker with Gadget's constructors.
Constructors
Let's delete the copy and move constructors. We also need to delete getGadget_val as that implicitly uses those.
#include <iostream>
using std::cout;
struct Gadget {
// members
int giovanni;
int giorgio;
// constructor
Gadget(int giov, int gior): giovanni(giov), giorgio(gior) {}
Gadget(const Gadget&) = delete;
Gadget(const Gadget&&) = delete;
// a convenient method
void tellMe() {
cout << "giovanni: " << giovanni << ", " << &giovanni << "\n";
cout << "giorgio: " << giorgio << ", " << &giorgio << "\n\n";
}
};
class Widget {
public:
// members
int myInto;
Gadget myGadget;
// constructor
Widget(int giov, int gior, int myo): myGadget(giov, gior), myInto(myo) {}
// info
void tellMe() {
cout << "myInto: " << myInto << ", " << &myInto << "\n";
myGadget.tellMe();}
Gadget& getGadget_ref() {return myGadget;}
// we had to eliminate the _val version
};
int main() {
Widget w{2,8,77};
w.tellMe();
Gadget& g1{w.getGadget_ref()};
g1.tellMe();
// Gadget g2{w.getGadget_ref()};
// does not compile: we deleted the copy constructor
}
As we can see in the last line, we can't make a copy as the copy constructor has been deleted. Just for fun, let's keep the move constructor deleted, but not the copy constructor. This should allow us to make copies, right? Well, as it turns out this code does not compile:
// does not compile!
#include <iostream>
using std::cout;
struct Gadget {
// members
int giovanni;
int giorgio;
// constructor
Gadget(int giov, int gior): giovanni(giov), giorgio(gior) {}
Gadget(const Gadget&&) = delete;
// a convenient method
void tellMe() {
cout << "giovanni: " << giovanni << ", " << &giovanni << "\n";
cout << "giorgio: " << giorgio << ", " << &giorgio << "\n\n";
}
};
class Widget {
public:
// members
int myInto;
Gadget myGadget;
// constructor
Widget(int giov, int gior, int myo): myGadget(giov, gior), myInto(myo) {}
// info
void tellMe() {
cout << "myInto: " << myInto << ", " << &myInto << "\n";
myGadget.tellMe();}
// getters: by value, by reference
Gadget getGadget_val() {return myGadget;}
Gadget& getGadget_ref() {return myGadget;}
};
int main() {
Widget w{2,8,77};
Gadget g1{w.getGadget_val()};
}
// does not compile!
The reason being the copy constructor has been implicitly deleted by our deletion of the move constructor. To remedy, we need to be a bit more explicit about the copy constructor. For example by making it default.
#include <iostream>
using std::cout;
struct Gadget {
// members
int giovanni;
int giorgio;
// constructor
Gadget(int giov, int gior): giovanni(giov), giorgio(gior) {}
Gadget(const Gadget&) = default;
Gadget(const Gadget&&) = delete;
// a convenient method
void tellMe() {
cout << "giovanni: " << giovanni << ", " << &giovanni << "\n";
cout << "giorgio: " << giorgio << ", " << &giorgio << "\n\n";
}
};
class Widget {
public:
// members
int myInto;
Gadget myGadget;
// constructor
Widget(int giov, int gior, int myo): myGadget(giov, gior), myInto(myo) {}
// info
void tellMe() {
cout << "myInto: " << myInto << ", " << &myInto << "\n";
myGadget.tellMe();}
// getters: by value, by reference
Gadget getGadget_val() {return myGadget;}
Gadget& getGadget_ref() {return myGadget;}
};
int main() {
Widget w{2,8,77};
Gadget g1{w.getGadget_val()};
}
Top comments (0)