函数参数有默认值，调用的时候可以传值，可以不传值

可变参数，循环读取

void func(int i,...)
{
    //可变参数指针
    va_list args_p;
    //开始读取可变参数，i是最后一个固定参数
    va_start(args_p,i);
    int value;
    while (1){
        value = va_arg(args_p,int);
        if (value <= 0){
            break;
        }
        cout << value << endl;
    }

    //结束
    va_end(args_p);
}

void main(){
    func(9, 20, 40, 30);
    system("pause");
}

构造函数，析构函数，拷贝构造函数

构造函数

class Teacher{
private:
    char *name;
    int age;
public:
    //无参构造函数（写了，就会覆盖默认的无参构造函数）
    Teacher(){
        cout << "无参构造函数" << endl;
    }
    //有参构造函数会覆盖默认的构造函数
    Teacher(char *name, int age){
        this->name = name;
        this->age = age;
        cout << "有参构造函数" << endl;
    }   
};
void main(){
    //Teacher t1;
    Teacher t2("yuehan",20);

    //另外一种调用方式
    Teacher t3 = Teacher("jack",21);

    system("pause");
}

析构函数

class Teacher{
private:
    char *name;
    int age;
public:
    //无参构造函数赋默认值
    Teacher(){
        this->name = (char*)malloc(100);
        strcpy(name,"jack walson");
        age = 20;
        cout << "无参构造函数" << endl;
    }
    //析构函数
    //当对象要被系统释放时，析构函数被调用
    //作用：善后处理
    ~Teacher(){
        cout << "析构" << endl;
        //释放内存
        free(this->name);
    }
};
void func(){
    Teacher t1;
}
void main(){
    func();
    system("pause");
}

拷贝构造函数

浅拷贝拷贝的是指针的地址，深拷贝拷贝的是指针指向的数据内容

浅拷贝

class Teacher{
private:
    char *name;
    int age;
public:
    Teacher(char *name, int age){
        this->name = name;
        this->age = age;
        cout << "有参构造函数" << endl;
    }
    //拷贝构造函数（值拷贝）
    //默认拷贝构造函数，就是值拷贝
    Teacher(const Teacher &obj){
        this->name = obj.name;
        this->age = obj.age;
        cout << "拷贝构造函数" << endl;
    }
    void myprint(){
        cout << name << "," << age << endl;
    }
};

Teacher func1(Teacher t){
    t.myprint();
    return t;
}

void main(){
    Teacher t1("rose",20);

    //拷贝构造函数被调用的场景
    //1.声明时赋值
    //Teacher t2 = t1;
    //t2.myprint();
    //2.作为参数传入，实参给形参赋值
    func1(t1);
    //3.作为函数返回值返回，给变量初始化赋值
    //Teacher t3 = func1(t1);

    //这里不会被调用
    //Teacher t1 ;
    //Teacher t2;
    //t1 = t2;

    system("pause");
}

深拷贝

class Teacher{
private:
    char *name;
    int age;
public:
    Teacher(char *name, int age){
        int len = strlen(name);
        this->name = (char*)malloc(len+1);
        strcpy(this->name, name);
        this->age = age;
        cout << "有参构造函数" << endl;
    }
    ~Teacher(){
        cout << "析构" << endl;
        //释放内存
        free(this->name);
    }
    //深拷贝
    Teacher(const Teacher &obj){
        //复制name属性
        int len = strlen(obj.name);
        this->name = (char*)malloc(len+1);
        strcpy(this->name,obj.name);
        this->age = obj.age;
    }
    void myprint(){
        cout << name << "," << age << endl;
    }
};
void func(){
    Teacher t1("rose", 20);

    Teacher t2 = t1;
    t2.myprint();
}
void main(){
    func();
    system("pause");
}

构造函数的属性初始化列表

先创建属性，即先调用Teacher有参构造方法，析构函数是先调用student的

class Teacher{
private:
    char* name;
public:
    Teacher(char* name){
        this->name = name;
        cout << "Teacher有参构造函数" << endl;
    }
    ~Teacher(){
        cout << "Teacher析构函数" << endl;
    }
    char* getName(){
        return this->name;
    }
};
class Student{
private:
    int id;
    //属性对象
    //Teacher t = Teacher("miss cang");
    Teacher t1;
    Teacher t2;
public:
    Student(int id,char *t1_n, char* t2_n) : t1(t1_n), t2(t2_n){
        this->id = id;
        cout << "Student有参构造函数" << endl;
    }
    void myprint(){
        cout << id << "," << t1.getName() <<"," << t2.getName() << endl;
    }
    ~Student(){
        cout << "Student析构函数" << endl;
    }
};
void func(){
    Student s1(10, "miss bo", "mrs liu");
    s1.myprint();
}
void main(){
    func();
    system("pause");
}

友元函数

friend void modify_i(A *p, int a);
友元函数的实现，在友元函数中可以访问私有的属性

void modify_i(A *p, int a){
    p->i = a;//i为私有属性
}

B是作为A里的友元属性，友元类friend class B;
B这个友元类可以访问A类的任何成员

运算符重载

//当属性私有时，通过友元函数完成运算符重载
class Point{
    friend Point operator+(Point &p1, Point &p2);
private:
    int x;
    int y;
public:
    Point(int x = 0, int y = 0){
        this->x = x;
        this->y = y;
    }   
    void myprint(){
        cout << x << "," << y << endl;
    }
};
Point operator+(Point &p1, Point &p2){
    Point tmp(p1.x + p2.x, p1.y + p2.y);
    return tmp;
}
void main(){
    Point p1(10, 20);
    Point p2(20, 10);
    //运算符的重载，本质还是函数调用
    //p1.operator+(p2)
    Point p3 = p1 + p2;
    p3.myprint();
    system("pause");
}