C++面向对象的讲解（一）（简单学习）
C++类的讲解
1、面向对象和类的介绍
1）面向对象
C语言使用面向过程的编程方式，而C++则增加了面向对象的编程方式。
面向过程：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象 ：把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。 性能对比:
优缺点：
1）面向对象易维护、易复用、易扩展。 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，面向对象性能比面向过程低。
2）面向过程性能比面向对象高。 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是，面向过程没有面向对象易维护、易复用、易扩展。
面向对象的三大特性：封装、继承、多态
2）类
类是一种将抽象（问题的本质）转换成用户自定义的类型的一种C++工具，它将数据表示和操纵数据的方法组合成了一个整洁的包。这个包提供对外的接口让用户调用。
类与结构的区别：类是C++对结构进行扩展后的结果。但结构的默认访问类型是public，而类为private。
2、类的建立
1、类的声明
（继承相关的内容在之后会讨论）
#include关键字public和private和protect是类的控制访问，在类中的顺序没有固定要求，这三个分别描述了对类成员的不同的访问权限。但类中可以互相调用彼此，不受限制。
当没有使用任何的访问控制关键字时，默认算是private！
3、成员函数
1、成员函数的说明
1、类中成员函数有三种定义方式
1）直接在类中定义
class student
{
public:
void function(int a,int b){//在类中直接建立函数，并调用私有成员里的变量
x=a;
y=b;
}
private:
int x,y;
}
2）在类声明中只给出成员函数的原型，成员函数的定义则放在类的外部
class student
{
public:
void function(int,int);//声明函数的返回类型（void），形参类型（int），函数名（function）
private:
int x,y;
}
void student::function(int a,int b)//::表示作用域，student::放在前面表示声明的函数属于student类
{
x=a;
y=b;
}
3）将函数作为内联函数进行处理
class student
{
public:
inline void function(int,int);//inline表示内联函数，声明函数的返回类型（void），形参类型（int），函数名（function）
private:
int x,y;
}
inline void student::function(int a,int b)//inline表示内联函数，::表示作用域，student::放在前面表示声明的函数属于student类
{
x=a;
y=b;
}
2、成员函数的使用
使用成员运算符调用成员函数
class print
{
public:
void _print(){
cout<<"你好！";
}
}
int main(){
print s;
s.print();
return 0;
}
输出：
你好！
4、构造函数和析构函数
构造函数的介绍：
当类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数，其作用是初始化对象的数据成员。
构造函数在类中不可缺少且函数名与类相同，构造函数不能有返回类型和返回值。
构造函数可以重载！（即下面几种构造函数可以共存）
构造函数建立在公有成员中，否则外部类对象无法调用构造函数来实现数据成员初始化！！！
构造函数的分类：
1）默认构造函数
如果你创建一个类时没有写任何构造函数，系统会自动生成默认的无参构造函数
class student
{
public:
/*
student(void){//系统自动创建的无参构造函数，但默认值可能不为0
x=0;
y=0;
}
*/
void function(int,int);//声明函数的返回类型（void），形参类型（int），函数名（function）
private:
int x,y;
}
2）初始化构造函数
class student
{
public:
student(int _x,int _y){//可以在类的对象建立的时候初始化对象内的数据的值
x=_x;
y=_y;
}
private:
int x,y;
}
int main(){
student s(5,6);//调用了构造函数，将5和6传递给了s对象里的x和y，使对象s内数据成员被初始化了
return 0;
}
3）复制（拷贝）构造函数
用于对象之间的值传递
默认拷贝构造函数
即没有定义构造函数，此时编译器会给我们自动产生一个拷贝构造函数，其作用是将另一个对象里的所有数据复制到该对象。
class student
{
public:
private:
int x,y;
}
int main(){
student s(5,6);
student c=s;//或者student c(s),作用相同，使用默认拷贝构造函数，将对象s当作参数传入c对象中，把s中所有数据传给对象c
}
自定义拷贝构造函数
可以自己定义要传送的数据
class student
{
public:
student(const student& c){//将对象c的x的值传给该类对象中的x，这里要传递的参数可以自己定义
x=c.x;
}
private:
int x,y;
}
int main(){
student s(5,6);
student c=s;//或者student c(s),作用相同，使用拷贝构造函数，将对象s当作参数传入c对象中，仅仅将s中的5传递给c中的x，没有全部传递（依据定义的拷贝构造函数）
}
4）类型转换构造函数
即实现类对象的数据类型的转换
只有一个参数
class student
{
public:
student(double c){//将对象c的x的数据类型变成double
x=c;
y=0;
}
private:
int x,y;
}
int main(){
student s=5.0;//调用了类型转换构造函数，将s.c的类型变成了double并赋值为5.0，c.y则为0
}
析构函数的介绍——
与构造函数相反，析构函数是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在生命周期结束时，C++编译系统会自动调用析构函数，来完成类的一些资源清理工作。
析构函数的特性——
1）析构函数名是在类名前加上字符~，且无返回类型，无参数，无返回值。
2）一个类有且只有一个析构函数。若用户没有显式定义，系统会自动生成默认的析构函数。
3）析构函数因为没有参数所以不能重载
class student
{
public:
student(int _x,int _y){//可以在类的对象建立的时候初始化对象内的数据的值
x=_x;
y=_y;
}
~student(){}//析构函数
private:
int x,y;
}
5、类的运算符重载
当我们使用string类时，经常会用到 string定义的两个对象直接相加，这是怎么办到的呢？
这就用到了类的运算符重载，即在类中定义一个该对象与其他对象的运算函数，最后返回该对象，实现两个类的运算。
双目运算符形参为另一对象，单目运算符则不必写形参名！
class student
{
public:
student operator +(const student&c){//student为返回类型，const student&c为参数，+为运算符，使用const表示只读，不能改变对象c内的数据
x=x+c.x;//this.x=this.x+c.x
y=y+c.y;//this.y=this.y+c.y
return *this;//返回this指针
}
private:
int x,y;
}
int main(){
student s(5,6);
student c=s;
c=c+s;//c.x=10,c.y=16
//另一种写法：c=operator+(c,s)
}
这里补充关于this指针的知识点：
在C++中，每个对象都能通过this指针来访问自己的地址。this指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
class student
{
public:
/*student(int _x,int _y){//省略this指针写法
this.x=_x;
this.y=_y;
}*/
student(student *const this,int _x,int _y){//编译器眼中的函数
x=_x;
y=_y;
}
private:
int x,y;
}
关于const与函数的补充：
当const在函数名前面的时候修饰的是函数返回值，在函数名后面则表示是常成员函数，该函数不能修改对象内的任何成员，即只能发生读操纵，不能发生写操作！
6、友元函数
1、为什么要使用友元函数？
类的封装性实现了数据隐藏，即类的私有成员在该类的作用域之外是不可见的。
但有时可能需要在类的外部访问类的私有成员，
为此 C++提供了一种允许类外的函数或其他的类访问该类的私有成员的方法，它通过关键字 friend 把其他类或函数声明为一个类的友元。
2、友元函数的定义与声明
友元函数是声明在类体内的一般函数，也可以是另一个类中的成员函数。友元函数并不是这个类中的函数，但它具有这个类中成员函数所具有的访问该类所有成员的功能。
1）使用普通函数作为友元函数
这样可以使用普通函数（已经定义的友元函数）在外部调用该类的数据成员。
语法：
friend 函数返回值类型 函数名(形式参数列表);
例子：
class student
{
public:
student(int _age, string _name, string _id) {
age = _age;
name = _name;
id = _id;
}
friend void function1(student &a) {//定义友元函数，作用：年龄+1，类型为student，即类名，使用&是为了传递可以改变的参数，作用类似指针
a.age++;
}
friend int function2(student &a,student &b){//定义友元函数，返回两个对象的年龄和
return a.age+b.age;
}
void print() {
cout << age << " " << name << " " << id;
}
private:
int age;
string name;
string id;
};
int main() {
student s1(23,"波哥","2017217293");
student s2(23,"徽哥","2017217292")
function1(s1);//23+1
int s=function2(s1,s2);//24+23
s.print();
}
从上例可以看出，
- 友元函数与普通函数的唯一区别就是友元函数需要在类中定义；
- 友元函数（使用普通函数）的调用不用通过对象和 . 运算符，可以直接在外部调用；
- 因为友元函数是要从外部访问类对象内部的，所以友元函数的形参里需要出现类对象，以便调用；
- 因为友元函数是在类中定义的，所以可以调用形参中对象的内部数据
2）类的成员函数作为另一个类的友元函数
类中的成员函数作为另一个类的友元函数，其语法格式如下：
friend 类名::函数返回值类型 函数名(形式参数列表);
例子：
#include 3、注意事项
在使用友元函数时，还需要注意以下几点：
- 友元函数必须在类的定义中声明；
- 友元函数的声明可以出现在类的任何地方，包括在 private 和 protected 部分；
- C++ 不允许将某个类的构造函数、析构函数和虚函数声明为友元函数。