deep copy and shallow copy

Shallow copy: Simple assignment copy operation.
Deep copy: Re-apply for space in the heap memory and perform a copy operation.

Note that this is different from the deep copy and shallow copy in python.

Classes & Objects

class access modifier

piblic: Members can be accessed both inside and outside the class.

private: Accessible only within the class and friend functions, not outside the class.

protect: Accessible within the class and subclasses, not accessible outside the class.

Member attributes are recommended to be encapsulated as private and exposed through public methods.

Inheritance method:

describe

constructor and destructor

Constructor: It is used for the initialization of member properties, and is automatically called by the system when an object is created.

Destructor: The system performs some cleanup work before the object is destroyed.

Constructors and destructors do not return any value, nor do they return void.
Constructors can have parameters and can be overloaded.
The constructor has the same name as the class.
The destructor cannot have parameters and cannot be overloaded.
The destructor has the same name as the class, preceded by~

Types of constructors:

Divided according to parameters: construction with parameters and construction without parameters
Divided by type: ordinary construction and copy construction

Note: Do not initialize anonymous objects with a copy constructor

Constructor overloading:

The constructor can be overloaded in various ways, just be careful not to cause ambiguity. For example, in the following situation, an error will occur during initialization. The second constructor with parameters is given a default value, so it can be called without passing any parameters. This is ambiguous with the no-argument constructor:

class Student
{
    
    
    public:
        string name;
        int age;

        Student();
        Student(string, int);
};

Student::Student()
{
    
    
    cout << "无参构造函数" << endl;
}

Student::Student(string name="xiaoming", int age=18)//这里全部加默认参数会和无参构造函数出现歧义
{
    
    
    cout << "有参构造函数" << endl;
    this->name = name;
    this->age = age;
}

Various initialization methods of objects

bracketing

Student p1;
Student p2("xiaoming", 18);
Student p3(p2);

display method

Student p1;
Student p2 = Student("xiaoming", 18);
Student p3 = Student(p2);

Implicit conversion method (not intuitive enough)

Student p4 = {
      
      "xiaoming", 18};
Student p5 = p4;

Full example:

#include <iostream>
#include <string>

using namespace std;

class Student
{
    
    
    public:
        string name;
        int age;

        Student();
        Student(string, int);
        Student(const Student & p);
        ~Student();

        void set_age(int age);
        int get_age();
};

Student::Student()
{
    
    
    cout << "无参构造函数" << endl;
}

Student::Student(string name, int age)
{
    
    
    cout << "有参构造函数" << endl;
    this->name = name;
    this->age = age;
}

Student::Student(const Student & p)
{
    
    
    cout << "拷贝构造函数" << endl;    
}

Student::~Student()
{
    
    
    cout << "析构函数" << endl;
}

void Student::set_age(int age)
{
    
    
    this->age = age;
}

int Student::get_age()
{
    
    
    return this->age;
}

int main()
{
    
    
    //方法1
    Student stu1; //注意stu1不能加括号，否则编译器会将其看成函数声明
    //方法2
    Student stu2("xiaoming", 10);
    //方法3
    Student stu3 = Student();
    //方法4
    Student(); //匿名对象，当前行结束后，系统回收内存
    //方法5 new方法在堆内存创建对象
    Student * student = new Student("xiaoming", 20);
    delete student;
	//方法6
	Student stu6 = {
    
    "小明", 20};

    system("pause");
    return 0;
}

When to call the copy constructor:

Initialize a new object using an already created object
Passing parameters to functions by value
returns the local object by value

Constructor calling rules

By default, when creating a class, the c++ compiler will add at least three functions to each class
- default constructor (empty implementation)
- destructor (empty implementation)
- copy constructor (value copy)
If you write a parameterized construction yourself, the compiler will no longer provide a default construction, but will provide a copy constructor .
If we write a copy constructor, the compiler doesn't provide any constructor anymore.

Note: In the copy constructor, if the attribute is opened in the heap area, you must provide the copy constructor yourself to prevent problems caused by shallow copy.

friend function

keywords:frind

Can access private members of the class

Three implementations:

Global functions as friends
class as friend
member function as friend

This pointer

This points to the object to which the called function belongs.

resolve name conflicts
Return the object itself with*this

static member

Static member variable:

All objects share the same data
Allocate memory during compilation
In-class declaration, out-of-class initialization

Static member function:

All objects share the same function
Static member functions can only access static member variables
Static member function does not have this pointer
It can also be used when not creating an object

Learning C++: Classes and Objects