一.构造函数

C++ 中类的构造函数与 java 很类似,其实对于面向对象编程来说,大家伙都是一个思想,可能语法上有所不同而已。

class Student
{
public:
    // 构造函数
    Student(){// 空参数构造函数
        cout << "空参数构造函数"<< endl;
    }

    // Student(char* name):age(0){// 一个参数构造函数, 相当于 this->age = 0
    //  cout << "一个参数构造函数" << endl;
    //  this->name = name;
        // this->age = 0;
    // }

    Student(char* name) :Student(name,0){// 调用两个参数的构造函数,注意:先会调用两个参数的构造函数,然后才会执行当前构造函数
        cout << "一个参数构造函数" << endl;
    }

    Student(char* name, int age){// 两个参数构造函数
        cout << "两个参数构造函数" << endl;
        this->name = (char*)malloc(sizeof(char)*100);
        strcpy(this->name,name);
        // this->name = name;
        this->age = age;
    }

private:
    int age;
    char* name;
}

void main(){

    // Student stu;// 1. 默认调用空参的构造函数
    // stu.setAge(24);
    // stu.setName("Darren");

    // Student stu("Darren",24); // 2. 调用两个参数的构造函数

    // 3. 用 new 关键字,返回的是一个 Student 的一级指针
    // Student *stu = new Student("Darren",24);

    // 4. 用 malloc 的方式,并没有调用空参的构造函数
    // Student *stu = (Student*)malloc(sizeof(Student));
    // stu->setAge(24);
    // stu->setName("Darren");

    // 构造函数相互调用
    Student *stu = new Student("Darren");

    cout << stu -> getName() << " , " << stu->getAge() << endl;

    getchar();
}

需要注意的是属性初始化的时候要用 :属性名(初始值),构造函数之间需要相互调用时用 :构造函数名(参数值),具体请看上面的事例代码。

二.析构函数

在 C++ 中当一个对象被回收的时候,会调用该对象的析构函数,一般来讲我们都会在析构函数中做一些释放内存的操作,当然如果不处理不好,也可能出现宕机的情况。这在 java 中似乎很少见,因为 java 都是由 JVM 自动管理内存的,但其实 java 类也有一个析构函数。在腾讯面试的时候就遇到了这么一个笔试题:请说出 finalize,finally,final 之间的区别。

// 2. 析构函数,如果有在对象内部开辟堆内存,可以在析构函数中释放内存
~Student(){
  cout << "析构函数" << endl;
  // 临终遗言,对象被回收的时候会被调用
  // 释放内存
  free(this->name);
  this->name = NULL;
}

void main(){
    Student *stu = new Student();
    delete(stu);
    getchar();
}
二.拷贝构造函数

在 java 中如果 Student stu2 = stu1,那么我们一般会认为 stu2 对象和 stu1 对象是同一个对象,但是在 c++ 中这种认为就是错误的,我们可以分别打印 stu1 和 stu2 的地址发现并不相等,所以 stu1 和 stu2 并不是同一个对象,而是会调用拷贝构造函数。

// 4.拷贝构造函数,对象会有一个默认的拷贝构造函数,用来对象之间的赋值
Student(const Student& stu){// 常量的引用
  cout << "拷贝构造函数" << endl;
  // this->name = stu.name;// 浅拷贝
  // 如果动态开辟内存,一定要采用深拷贝
  this->name = (char*)malloc(sizeof(char)* 100);
  strcpy(this->name, stu.name);
  this->age = stu.age;
}

Student getStudent(char* name){
    Student stu(name);// 栈 ,方法执行完,这个对象会被回收,但是发现调用了拷贝构造函数
    cout << &stu << endl;
    return stu;// 会返回一个新的 Student 对象,而栈内开辟的 stu 是会被回收
}


void printStudent(Student stu){// stu 是该方法栈中一个新的对象,拷贝构造函数赋值,方法执行完会调用析构函数
    cout << stu.getName() << " , " << stu.getAge() << endl;
}

void main(){
    // 1. = 会调用拷贝构造函数
    // Student stu1("Darren", 24);
    // Student stu2 = stu1; // = 是赋值,把里面所有定义的属性赋值,c/c++ 编译器帮我们做的,其实会调用对象的拷贝构造

    // Student stu2;// 声明变量,开辟变量内存
    // stu2 = stu1; // 这个不会去调用拷贝构造函数,但是会赋值 c 的类似

    // 2. 第二种场景 作为参数返回的时候会调用拷贝构造函数
    // Student stu = getStudent("Jack");
    // cout << &stu << endl;

    // 3. 第三种场景 作为参数传递的时候会调用拷贝构造函数
    // Student stu("Darren", 24);
    // printStudent(stu);

    // 知识的补充
    Student stu = getStudent("Jack");

    // cout << stu.getName() << " , " << stu.getAge() << endl;

    printStudent(stu);

    getchar();
}