C++ 面向对象

// Student.h

class Student {
private: // 私有的，外界不能访问
    char *name;
    int age;

public:
    void setAge(int age);
    void setName(char* name);
    int getAge();
    char* getName();

    // 空参构造函数
    Student(){
    }

    // 一参构造函数
    Student(char* name) : Student(name,80) {
        // 调用两参的构造函数，与 java 有点不同，又与 Kotlin 继承调用父类构造有点像
    }

    // 两参构造函数
    Student(char* name, int age) {
    }

    // 析构函数 对象的临终遗言，一般用来做释放工作，与 java 的 finalize() 类似
    ~Student() {
    }

    // 拷贝构造函数，它默认有，可以重写
    // 对象1 = 对象2
    Kang(const Kang &kang) { // 常量引用：只读
        // 可以对原来的对象做一些操作
    }

    // const修饰方法后面：只读的函数
    void showInfo() const {
    }

    // 定义友元函数，供外界重写来访问私有成员
    friend void updateAge(Kang *kang,int age);

    // 友元类，友元类可访问自身的私有成员
    friend class Person;
    // java 中能用反射获取到其他类私有成员，底层就是友元实现的

};

 与 java 一样，C++也是面向对象的，和 java 非常相似：
新创建一个头文件 Student.h，里面定义了一个 Student 类

构造函数：和 java 相比大部分相同，只是在构造函数之间的相互调用有一些出入
析构函数：在对象销毁时会调用此函数，类似 java 的 finalize()
拷贝构造函数：在对象之间直接赋值会调用此函数，可以在赋值时做一些操作

友元函数 / 类：都基于友元思想，只能在类中定义，友元函数供外界重写来访问私有成员，友元类能直接访问私有成员

---

// Student.cpp

#include "Student.h"

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

void Student::setName(char *name) {
    this->name = name;
}

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

char *Student::getName() {
    return this->name;
}

为了演示，我只在实现文件实现 get/set，其实把全部函数的实现都写在头文件都可以的，但是为了解耦和可读性，最好还是在头文件声明，实现文件中进行实现

---

#include  // C++ 的标准支持
#include "Student.h"

// new/delete 是一套 会调用构造函数 与 析构函数 【C++标准规范】
// malloc/ free 是一套 不调用构造函数 与 析构函数 【C的范畴，虽然不推荐，但是也是可以的】

int main() {

    Student s1; // 调用空参构造函数（栈区开辟）
    Student s2("小民"); // 调用一个参数的构造函数（栈区开辟）

    // new 关键字返回的是对象的指针
    Student *s3 = new Student("小红"); // 调用一个参数的构造函数（堆区开辟）
    delete s3;

    // 调用拷贝构造函数
    Student s4 = s1;

    return 0;
}

与 java 不同，像 Student s1，java 只是定义了一个空的变量，而 C++ 是实打实的创建了一个对象

在 new 的时候，C++返回的是一个指针，销毁时需要手动调用 delete 做释放工作。