Downloaded 450 times
Uploaded byJussi Pohjolainen
C++: Constructor, Copy Constructor and Assignment operator
The document discusses various C++ constructors including default constructors, initialization lists, copy constructors, assignment operators, and destructors. It provides examples of how to properly implement these special member functions to avoid problems like shallow copying and double deletes.
In this document
Powered by AI
Introduction to C++ constructors as initialization functions, outlining default constructors and their roles in object member initialization.
Definition of a Point class in C++ showing member variables and constructor for coordinates.
Demonstrates usage of the Point class by creating an instance and displaying coordinates.
Explanation of default constructors that can be invoked without parameters.
Discussion about initialization lists for efficient class member initialization in C++ constructors.
Uses of the 'this' pointer in class methods to reference the current object instance.
Introduction to mutator methods for setting coordinates in the Point class.
Overview of destructors functioning as cleanup for class instances.
Discussion of copy constructors, illustrating object copying and how C++ creates default ones.
Example of implementing a copy constructor for the Point class and showcasing its application.
Demonstrating shallow clones with a Line class and potential issues with deep data.
Guidelines for implementing deep cloning to avoid shallow copy problems in class instances.
Introduction to assignment operators and how they handle object assignment.
Code examples for implementing assignment operators in the Point class.
Illustrates memory errors due to default shallow copy assignment for complex classes.
Implementing deep copy in the Person class assignment operator to prevent double-free issues.
C++: Constructor, Copy Constructor and Assignment operator
- 1. C++ Constructors JussiPohjolainen TAMK University of Applied Sciences
- 2. Constructors Constructor isa “init function” that is called when an object is created C++ provides default constructor (= constructor with no parameters) Constructor has the same name than the class Constructor does not return anything Constructor usually initalizes class members
- 3. point.h #ifndef _POINT_H_#define _POINT_H_ class Point { private: int x_; int y_; public: Point(int x, int y); int GetX(); int GetY(); }; #endif
- 4. point.cpp #include "point.h"Point::Point(int x, int y) { x_ = x; y_ = y; } int Point::GetX() { return x_; } int Point::GetY() { return y_; }
- 5. main.cpp #include <iostream>#include ”point.h" using namespace std; int main() { Point p = Point(5,5); cout << p.GetX() << endl; return 0; }
- 6. Default Constructor Defaultconstructor is a constructor that can be called without parameters: class Example { public: Example(int x=0, int y=0); }
- 7. Initialization Lists Basicrule: initialize all class members in constructor Use initialization lists for initialization Initialization list is more efficient than assignment
- 8. Example of InitializationList #ifndef _POINT_H_ #define _POINT_H_ class Point { private: int x_; int y_; public: Point(int x, int y); }; #endif
- 9. Example of InitializationList #include "point.h" Point::Point(int x, int y) : x_(x), y_(y) { }
- 10. this - pointerthis pointer is used as a pointer to the class object instance by the member function This pointer stores the address of the class instance
- 11. Example about this #include <iostream> #include ”point.h" using namespace std; int main() { Point p = Point(5,5); cout << &p << endl; // prints 0xbffffa98 return 0; }
- 12. Example about this #ifndef _POINT_H_ #define _POINT_H_ class Point { private: int x_; int y_; public: Point(int x, int y); void PrintAddress(); }; #endif
- 13. Example about this #include "point.h" #include <iostream> using namespace std; Point::Point(int x, int y) : x_(x), y_(y) { } void Point::PrintAddress() { cout << this ; }
- 14. Example about this #include <iostream> using namespace std; #include "point.h" int main() { Point a(5,5); cout << &a << endl; // 0xbffffa98 a.PrintAddress(); // 0xbffffa98 return 0; }
- 15. Usage? #ifndef _POINT_H_#define _POINT_H_ class Point { private: int x ; int y ; public: void SetX(int x); void SetY(int y); }; #endif
- 16. Usage? #include "point.h”void Point::SetX(int x) { this->x = x ; } void Point::SetY(int y) { this->y = y ; }
- 17. Destructors Destructor isa function that is called when the object is released from memory You cannot overload destructors Class::~Class() { … }
- 18.
- 19. Introduction What happenshere? int main() { Point a(5,5); Point b = a; b.SetX(10); cout << a.GetX() << ", " << a.GetY() << endl; cout << b.GetX() << ", " << b.GetY() << endl; return 0; }
- 20. Copy Constructor Acopy constructor is called whenever a new variable is created from an object Point p(5,5); Point a = p; // Copy constructor call! Point b(p); // Copy constructor call! C++ creates default copy constructor automatically
- 21. Default Copy Constructorclass Point { private: int x_; int y_; public: Point(int x, int y); Point(const Point& p); int GetX(); int GetY(); void SetX(int x); void SetY(int y); };
- 22. Default Copy Constructor#include "point.h” Point::Point(const Point& p) { x_ = p.x_; y_ = p.y_; } ...
- 23. Default Copy Constructor#include <iostream> using namespace std; #include "point.h" int main() { Point a(5,5); // Constructor Point b = a; // Copy Constructor b = a; // Assignment! b.SetX(10); cout << a.GetX() << ", " << a.GetY() << endl; cout << b.GetX() << ", " << b.GetY() << endl; return 0; }
- 24. Shallow Cloning Problem?class Line { private: Point* begin_; Point* end_; public: Line(int x1, int y1, int x2, int y2); Line(const Line& l); ~Line(); };
- 25. Shallow Cloning Problem?Line::Line(int x1, int y1, int x2, int y2) : begin(new Point(x1,y1)), end(new Point(x2,y2)) { } Line::Line(const &Line l) { begin = l.begin; end = l.end; } Line::~Line() { delete begin; delete end; }
- 26. Shallow Cloning Problem?int main() { Line a(1,1,10,10); Line b = a; }
- 27. Implement your ownDeep Clone Line::Line(const &Line l) { int x1 = ( l.begin )->GetX(); int y1 = ( l.end )->GetY(); int x2 = ( l.begin )->GetX(); int y2 = ( l.end )->GetY(); begin = new Point(x1, y1); end = new Point(x2, y2); }
- 28. Rules about CopyConstructors If shallow cloning is enough, do not implement copy constructor If you need deep copy, implement copy constructor Implement also destructor and assignment operator
- 29.
- 30. Assignment? #include <iostream>using namespace std; #include "point.h" int main() { Point a(5,5); // Constructor Point b = a; // Copy Constructor b = a; // Assignment! b.SetX(10); cout << a.GetX() << ", " << a.GetY() << endl; cout << b.GetX() << ", " << b.GetY() << endl; return 0; }
- 31. Assignment Operator #ifndefPOINT #define POINT class Point { private: int x_; int y_; public: Point(int x, int y); Point(const Point& p); Point& operator=(const Point& p); ~Point(); ... }; #endif
- 32. Assignment Operator Point&Point::operator=(const Point& p) { x_ = p.x_; y_ = p.y_; return *this; }
- 33. Assignment Operator intmain() { Point a(5,5); Point b(6,6); Point c(7,7); a = b; // <=> a.operator=(b); a = b = c; // <=> (a.operator=(b)).operator=(c); return 0; }
- 34. class Heart {public: int bloodAmount; }; class Person { public: Heart* heart; Person(); ~Person(); }; Person::Person() { heart = new Heart(); } Person::~Person() { delete heart; } int main() { Person a; Person b; a = b; } Result: a.out(8992) malloc: *** error for object 0x100160: double free *** set a breakpoint in malloc_error_break to debug WHY?
- 35. Why? A defaultassignment operator is used Default assignment operator makes shallow copy Result is two persons with one heart…
- 36. Deep copy Person&Person::operator=(Person& p) { delete heart; heart = new Heart(); heart->bloodAmount = p.heart->bloodAmount; return *this; }
- 37. What about now…int main() { Person a; a = a; } Person& Person::operator=(Person& p) { delete heart; heart = new Heart(); heart->bloodAmount = p.heart->bloodAmount; return *this; }
- 38. Correct Way intmain() { Person a; a = a; } Person& Person::operator=(Person& p) { if(this == &p) return *this; delete heart; heart = new Heart(); heart->bloodAmount = p.heart->bloodAmount; return *this; }