【类】
C语言使用函数将程序代码模块化，C++通过类将代码进一步模块化，类用于将实现一种功能的全局数据、以及操作这些数据的函数集中存储在一起，同时可以设置类成员的访问权限，禁止外部代码使用和篡改本类成员，类成员访问限制的功能由编译器提供，对程序进行逆向分析并修改时并不存在这些限制。
为了区分类成员与类外的全局数据、全局函数，类中的数据称为成员数据、类中的函数称为成员函数。
类的使用方式类似结构体，也是先声明再使用，类的实例称为对象，对象有类型之分，通过哪个声明定义的对象就属于哪个类型。
声明类时需要设置类成员访问权限，限制成员使用范围，类成员有三种访问权限：
1.private，私有成员，只有本类可以使用，外部代码、子类、内部类都不能使用。
2.protected，保护成员，本类和本类的子类可以使用。
3.public，公有成员，可以被任何外部代码使用。
多个类成员可以分别设置为不同的访问权限，编写代码时，类对外提供的功能定义为公有成员，不对外提供的功能定义为私有成员，若类成员未设置访问权限，则默认为私有成员，私有成员不能在类外部直接调用，但是可以被本类的公有成员在外部调用，从而让公有成员执行本类实现的功能。
类可以看做是结构体的扩充版，类可以存储函数，并为内部成员设置访问权限，实际上C++的结构体也可以当做类使用，在结构体内存储函数，结构体与类的唯一区别是成员默认访问权限不同，类成员默认为私有权限，结构体成员默认为公有权限，为了区分类与结构体，一般不会使用结构体代替类，结构体只用于将一些全局数据、成员数据分类存储。
#include <iostream>
/* 使用class声明类 */
class zoo
{
/* 公有成员 */
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
}; //以;符号结尾
int main()
{
zoo ali = {"阿狸", 8}; //创建类对象并为成员数据赋值，若类中定义了私有成员数据则不能在创建对象时直接赋值
ali.output(); //调用成员函数执行
return 0;
}对象本质
创建多个同类型对象时，这些对象只是成员数据的值不同，成员函数完全相同，这些对象完全没必要各自建立一份自用的成员函数，实际上编译器会对代码进行简化，让多个同类型对象共用一份成员函数。
#include <iostream>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
};
int main()
{
zoo ali = {"阿狸", 8};
ali.output();
zoo xyy = {"喜羊羊", 9};
xyy.output();
return 0;
}上述C++代码等同于如下C语言代码：
#include <stdio.h>
struct zoo
{
char name[50];
int age;
};
void output(struct zoo * this)
{
printf("姓名：%s\n年龄：%d岁\n\n", this->name, this->age);
}
int main()
{
struct zoo ali = {"阿狸", 8};
output(&ali);
struct zoo xyy = {"喜羊羊", 9};
output(&xyy);
return 0;
}创建对象时，编译器会将对象中的成员数据定义为一个结构体实例，多个对象共用一份成员函数，每个成员函数自动添加一个名为this的指针参数，this指向要操作的结构体实例，既然this指针是实际存在的参数，那当然可以直接使用它，比如下面的代码：
#include <iostream>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", this->name, this->age); //使用this指针参数调用成员数据
}
};
int main()
{
zoo ali = {"阿狸", 8};
ali.output();
zoo xyy = {"喜羊羊", 9};
xyy.output();
return 0;
}成员函数与对象的关系
在语法上，创建对象时包含成员函数，可以通过对象调用成员函数执行。
在功能上，成员函数独立于对象，成员函数通过this指针参数调用操作的对象。
对象使用方式
类对象会被编译为结构体实例，结构体实例的使用方式都可以转移到类对象中。
1.同类型的对象之间可以赋值。
2.对象可以作为函数参数和返回值。
3.类可以嵌套定义。
对象指针
对象指针使用方式类似结构体指针，使用对象指针调用内部成员时，只有成员数据使用指针调用，成员函数会转换为直接调用，原因是所有同类型对象共用一组成员函数，编译器通过“对象指针类型+函数名”即可确定要调用的函数，无需使用间接寻址。
#include <iostream>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
};
int main()
{
zoo ali = {"阿狸", 8};
zoo *p1 = &ali;
p1->output();
return 0;
}上述C++代码相当于如下C语言代码：
#include <stdio.h>
struct zoo
{
char name[50];
int age;
};
void put(struct zoo * this)
{
printf("姓名：%s\n年龄：%d岁\n\n", this->name, this->age);
}
int main()
{
struct zoo ali = {"阿狸", 8};
struct zoo *p1 = &ali;
output(p1); //直接调用函数，而非通过函数指针
return 0;
}构造函数与析构函数
构造函数和析构函数是编译器自动调用的成员函数，创建对象时自动执行构造函数，对象不再使用后自动执行析构函数。
构造函数
构造函数与类同名，可以在构造函数内定义创建对象后需要首先执行的一些代码，比如为对象赋值、申请内存、打开文件，当然也可以使用普通成员函数完成相关工作，但是普通成员函数需要手动调用，若忘记调用则可能出错。
构造函数使用特点如下：
1.构造函数可以没有，此时创建对象时编译器不会调用构造函数执行。
2.构造函数必须定义为公有权限，否则无法在外部执行。
3.可以有参数，此时需要在创建对象时为构造函数参数赋值，若无参数则完全由编译器自行管理。
4.不能有返回值，因为构造函数由编译器自动调用，无法接收返回值，若需与其他函数通信可以使用成员变量、全局变量实现。
5.可以被重载，编译器根据使用的参数确定调用的重载构造函数。
6.构造函数为对象成员数据赋值时，成员数据默认值不生效（成员数据默认值在之后讲解）。
7.若定义了构造函数，则不能在定义对象时直接为对象赋值，这种限制是为了防止直接赋值与构造函数赋值产生冲突。
#include <iostream>
#include <string.h>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
/* 构造函数 */
zoo()
{
name[0] = 0;
age = 0;
}
/* 重载构造函数 */
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
}
};
int main()
{
zoo x; //调用无参数构造函数
x.output();
zoo ali("阿狸", 8); //调用两个参数的构造函数
ali.output();
zoo xyy = {"喜羊羊", 9}; //这种语法表示为构造函数参数赋值，而不是直接为对象赋值，{}符号内的数据对应构造函数参数，而非成员数据
xyy.output();
return 0;
}析构函数
析构函数会在对象使用完毕后自动执行，可以在析构函数内定义一些函数执行完毕后需要执行的代码，比如释放内存、关闭文件，析构函数也是与类同名，但是需要前缀~符号与构造函数区分。
析构函数执行条件如下：
1.创建此对象的函数执行完毕。
2.对象使用new申请内存存储，之后调用delete释放了内存。
析构函数使用特点如下：
1.析构函数可以没有，此时编译器不会调用析构函数执行。
2.必须定义为公有权限，否则无法在外部执行。
3.没有参数，也没有返回值，若需与其它函数通信可以使用全局变量实现。
#include <iostream>
#include <string.h>
class zoo
{
public:
char name[50];
int age;
/* 构造函数 */
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
printf("zoo构造函数执行\n");
}
/* 析构函数 */
~zoo()
{
printf("zoo析构函数执行\n");
}
};
int main()
{
zoo ali("阿狸", 8);
printf("main函数执行完毕\n");
return 0;
}编译以上代码并执行，观察构造函数、析构函数的执行顺序。
嵌套类
嵌套定义的类称为内部类，内部类将会当做所属类的成员使用，多数情况下内部类设置为私有权限，不对外开放，只供所属类的其它成员使用。
#include <iostream>
class zoo
{
private:
class fox
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
};
public:
fox ali = {"阿狸", 8};
fox taozi = {"桃子", 7};
void attr()
{
ali.output();
taozi.output();
}
};
int main()
{
zoo zoo1;
zoo1.attr();
return 0;
}类中定义本类对象
可以在本类中定义本类的对象，但是只能定义在成员函数内，因为成员函数本质上是独立于类的，若定义为成员数据将会产生无限循环嵌套，导致语法错误。
#include <iostream>
class zoo
{
public:
char name[50];
int age;
void f1()
{
zoo ali = {"阿狸", 8};
printf("姓名：%s\n年龄：%d岁\n\n", ali.name, ali.age);
}
};
int main()
{
zoo zoo1;
zoo1.f1();
return 0;
}使用new申请对象内存
不带构造函数
#include <iostream>
#include <string.h>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
~zoo()
{
printf("zoo析构函数执行\n");
}
};
int main()
{
zoo * p1 = new zoo;
strncpy(&p1->name[0], "阿狸", 49);
p1->age = 8;
p1->output();
delete p1; //使用delete释放内存后会自动调用对象析构函数
printf("main函数执行完毕\n");
return 0;
}带构造函数
#include <iostream>
#include <string.h>
class zoo
{
public:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n\n", name, age);
}
zoo()
{
name[0] = 0;
age = 0;
}
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
}
};
int main()
{
zoo * p1 = new zoo(); //调用无参数构造函数
p1->output();
delete p1;
zoo * p2 = new zoo("阿狸", 8); //调用有参数构造函数
p2->output();
delete p2;
return 0;
}友元
类成员如果不考虑继承关系，只有公有、私有两种访问权限，要么禁止所有外部代码访问，要么允许所有外部代码访问，这种权限设置不灵活，所以C++增加了友元功能，友元是为某个外部代码单独设置的访问权限，可以让指定的类、成员函数、全局函数访问本类的私有成员。
友元最常用于内部类，将本类的内部类定义为友元，之后内部类就可以使用所属类的私有成员。
友元使用特点如下：
1.友元关系不会被继承。
2.友元关系是单向的，若需使用双向友元则需要在两个类中同时设置对方为自己的友元。
3.在友元中创建本类对象时不能直接赋值，可以使用构造函数赋值。
友元类
#include <iostream>
#include <string.h>
class zoo
{
/* 使用friend关键词设置k类为友元 */
friend class k;
private:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n", name, age);
}
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
}
};
class k
{
public:
void f1()
{
zoo ali("阿狸", 8);
ali.output();
}
};
int main()
{
k k1;
k1.f1();
return 0;
}友元成员函数
可以单独设置某个类的成员函数为友元，但是此函数必须在类外定义内容，并且有固定的定义顺序，顺序如下：
1.定义友元成员函数所属类。
2.定义需要设置友元关系的类。
3.在类外部定义友元成员函数的内容代码。
#include <iostream>
#include <string.h>
/* 定义友元成员函数所属类 */
class k
{
public:
void f1(); //只定义友元成员函数主体部分，不定义内容
};
/* 定义设置友元的类 */
class zoo
{
friend void k::f1(); //设置友元成员函数，若函数有参数则需要同时指定参数类型和名称
private:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n", name, age);
}
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
}
};
/* 定义友元成员函数内容 */
void k::f1()
{
zoo ali("阿狸", 8);
ali.output();
}
int main()
{
k k1;
k1.f1();
return 0;
}友元全局函数
#include <iostream>
#include <string.h>
class zoo
{
friend int main(); //设置main为友元
private:
char name[50];
int age;
void output()
{
printf("姓名：%s\n年龄：%d岁\n", name, age);
}
zoo(const char *s, const int i)
{
strncpy(name, s, 49);
age = i;
}
};
int main()
{
zoo ali("阿狸", 8);
ali.output();
return 0;
}
【成员数据使用细节】
成员数据默认值
声明成员数据时可以设置默认值，公有成员、私有成员都可以设置默认值，创建对象时若不赋值则编译器使用默认值自动赋值，若构造函数也会为对象赋值，则以构造函数为准。
#include <iostream>
class math
{
public:
int a=0, b=0; //设置默认值
void add()
{
printf("a+b=%d\n", a+b);
}
};
int main()
{
math math1; //使用默认值
math1.add(); //输出0
math math2 = {1,2}; //自行赋值
math2.add(); //输出3
return 0;
}常量成员数据
若成员数据定义为常量，则需要在创建对象时直接赋值，之后不能修改，只能读取它的值，若不为常量成员数据赋值则必须设置默认值。
注意不能使用构造函数为常量成员数据赋值，因为对象的创建早于构造函数的执行，此时等于使用构造函数修改常量成员数据，将会禁止编译。
私有成员数据
类成员应该尽量定义为私有的，不需要被外部代码调用的成员都应该设置为私有权限，防止被类外代码调用、修改导致出错，因为类成员不能在类外直接调用，所以类中包含私有成员数据时创建本类对象不能直接赋值，私有成员数据可以使用如下方式赋值：
1.设置默认值。
2.使用构造函数赋值。
3.使用其他公有函数赋值。
#include <iostream>
class math
{
private:
int a,b;
public:
void add()
{
printf("a+b=%d\n", a+b);
}
void mul()
{
printf("a*b=%d\n", a*b);
}
math(int i1, int i2)
{
a = i1;
b = i2;
}
};
int main()
{
math math1(1,2);
math1.add();
math1.mul();
return 0;
}
【成员函数使用细节】
成员函数在类外部定义内容
成员函数内容代码可以放在所属类外部定义，类中只定义成员函数的主体，这样方便阅读类实现的整体功能。
#include <iostream>
class math
{
private:
int a,b;
public:
void add(); //类中定义函数主体部分，若有参数则需要同时定义参数
void mul();
math(int i1, int i2)
{
a = i1;
b = i2;
}
};
/* 类外定义成员函数内容，因为不同类的成员可以同名，所以这里需要指定函数所属的类 */
void math::add()
{
printf("a+b=%d\n", a+b);
}
void math::mul()
{
printf("a*b=%d\n", a*b);
}
int main()
{
math math1(1,2);
math1.add();
math1.mul();
return 0;
}常量成员函数
常量成员函数是只读取成员数据、不修改成员数据的成员函数，而且它只能调用其他常量成员函数执行，不能调用非常量成员函数，这是为了防止通过调用非常量成员函数间接修改成员数据。
常量成员函数主要作用是服务于常量对象，对象可以定义为常量，防止被修改，常量对象中的成员函数只有常量成员函数可以执行，原因同上，类中不修改成员数据的函数都应该定义为常量成员函数，这样不仅可以被常量对象调用、还可以防止编写代码时不小心错误的修改了成员数据。
注：常量对象可以使用构造函数赋值，这与在类中定义常量成员数据不同，编译器会首先执行构造函数然后限制常量对象被修改。
#include <iostream>
class math
{
public:
int a,b;
/* 定义常量成员函数，const关键词写在参数之后 */
void add() const
{
printf("a+b=%d\n", a+b);
}
void mul() const
{
printf("a*b=%d\n", a*b);
}
};
int main()
{
const math math1 = {1,2}; //定义常量对象，只能调用常量成员函数执行
math1.add();
math1.mul();
return 0;
}成员函数指针
本类内部使用成员函数指针
#include <iostream>
class math
{
private:
int a,b;
public:
math(int i1, int i2)
{
a = i1;
b = i2;
}
int add() const
{
return a+b;
}
int mul() const
{
return a*b;
}
void output() const
{
int result;
int(math::*p1)()const = &math::add; //p1为指针名，const表示指向常量成员函数，赋值为add函数地址
result = (this->*p1)(); //使用指针执行成员函数
printf("a+b=%d\n", result);
p1 = &math::mul;
result = (this->*p1)();
printf("a*b=%d\n", result);
}
};
int main()
{
math math1(1,2);
math1.output();
return 0;
}使用成员函数指针注意事项如下：
1.定义成员函数指针时，需要指定指针所属类，此指针只能指向本类中的成员函数，包括继承自父类的函数。
2.成员函数指针赋值时，需要指定成员函数所属类，即使成员函数与成员函数指针就在同一个类中。
3.执行指针指向的函数时，需要使用this参数调用成员函数指针、然后通过成员函数指针调用指向的函数，编译器会使用本函数this参数为执行函数的this参数赋值。
本类外部使用成员函数指针
使用对象指针调用成员函数时会转换为直接寻址，成员函数并非通过指针调用，若有此需求可以在本类外部使用成员函数指针，成员函数在所属类之外通过指针调用时需要首先其所属类对象，并使用此对象的地址为成员函数的this参数赋值。
#include <iostream>
class math
{
private:
int a, b;
public:
math(int i1, int i2)
{
a = i1;
b = i2;
}
void add() const
{
printf("a+b=%d\n", a+b);
}
void mul() const
{
printf("a*b=%d\n", a*b);
}
};
int main()
{
math math1(1,2); //定义math对象
void(math::*p1)()const; //定义math类的成员函数指针
p1 = &math::add;
(math1.*p1)(); //通过指针执行函数，需要指定对象名，成员函数使用此对象为this参数赋值
p1 = &math::mul;
(math1.*p1)();
return 0;
}
【静态类成员】
类成员可以定义为静态的，静态成员直接通过类名调用，创建对象时不会包含类静态成员，就像C语言中静态局部变量等于全局变量、不包含在函数中一样。
静态类成员的作用是将一些全局数据、全局函数放在类中管理，方便将全局代码进行分类。
静态成员数据特点如下：
1.不能设置默认值，因为此数据本质上不属于此类成员。
2.需要在类外定义一遍，否则禁止编译，可以同时设置初始值，类内只是声明此数据的所属权，而非定义此数据。
静态成员函数特点如下：
1.不能操作所属类的非静态成员，因为静态成员函数没有this指针参数。
2.可以调用所属类的其它静态成员。
#include <iostream>
class math
{
public:
/* 静态成员数据 */
static int a, b;
/* 静态成员函数 */
static void add()
{
printf("a+b=%d\n", a+b);
}
};
int math::a = 0; //静态成员数据在类外定义
int math::b = 0;
int main()
{
math::a = 1; //使用类名调用静态类成员，也可以使用对象名调用，调用的都是同一个数据
math::b = 2;
math::add();
return 0;
}上述C++代码等同于如下C语言代码：
#include <stdio.h>
int a=0, b=0;
void add() //add函数没有this指针参数
{
printf("a+b=%d\n", a+b);
}
int main()
{
a = 1;
b = 2;
add();
return 0;
}静态类成员指针
静态类成员指针的定义方式与全局数据相同，只不过在赋值时需要额外指定数据所在类。
#include <iostream>
class math
{
public:
static int a, b;
static void add()
{
printf("a+b=%d\n", a+b);
}
};
int math::a = 0;
int math::b = 0;
int main()
{
int * p1 = &math::a;
*p1 = 1;
int * p2 = &math::b;
*p2 = 2;
void(*p3)() = &math::add;
p3();
return 0;
}
