函数参数有默认值，调用的时候可以传值，可以不传值
可变参数，循环读取
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");
}
