C++复习（七）——类和对象
C++复习（六）——类和对象
面向对象编程的基本思想
面型对象就是根据需要，将后续用到的各种变量、函数按类别打包到一起，这些不同的类别就是类，代入数据之后（实例化）得到的就是对象。
一、类与对象的定义
1.类
类是对数据（属性）与函数（行为）的封装，定义格式：
class 类名
{
private:
成员数据;
成员函数;
protect:
成员数据;
成员函数;
public:
成员数据;
成员函数;
}**;**
注：对三个关键字（又叫限定词）的解释
private：私有的。只能在类的内部使用，无法被派生类继承，无法在类外被调用。protect：保护的。只能在类的内部和类的子类之内被调用，不能在类外被调用。public：公有的。整个文件都有访问权限，是公开的。
限定词一旦使用，一直有效，直到下一个限定词出现。默认限定词为private。
成员函数可以只在类内做函数原型声明，在类外定义使用作用域运算符::定义函数体
函数类型 类名 ：：函数名（参数表）
{
函数体
}
在类定义时并未分配空间，不能直接对成员数据初始化。
2. 成员数据
1.访问私有数据
可以在public中定义函数，实现对私有数据的访问。可以使用一般变量，指针，引用作为参数。
2.对象
对象即类的实例，定义了对象之后会为对象分配空间，存储成员数据，但成员函数的代码是共享的。
定义对象的方式与一般变量相同：类名 对象名;
通过.运算符调用对象的成员数据与函数。
同类型的变量可以整体赋值
3.类指针
用法与一般指针相同，用来存储类的对象的地址
类名 *指针名
可以用类指针访问成员：p -> setx()
3.成员函数重载与线性表
成员函数重载与普通函数重载相同。
3.this指针
不同对象占据内存中的不同区域，它们的成员数据保存的位置各不相同，但对成员数据进行操作的成员函数的程序代码是同一段代码。当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，也隐含使用this指针。
this指针用来存放类对象的地址，在类内部访问其他成员函数，由于存在this指针，可以不使用对象名.成员函数的方式，在类外调用必须这样
二、构造函数和析构函数
1.构造函数
在类体内定义：
类名（参数表）
{
函数体
}
在类体外定义：
类名::类名（参数表）
{
函数体
}
1. 构造函数的特点：
- 参数可以缺省，可以无参。
- 可以重载
- 没有类型说明
- 无返回值
- 自动调用
- 以类名作为函数名
2. 当显式地定义了构造函数之后，系统不会自动生成缺省的构造函数。默认的（无参或缺省）构造函数只能有一个，即只能有一个构造函数可以在不提供参数而被调用。
3. 使用new运算符动态建立对象时可以直接初始化
A *pa1,*pa2;
pa1=new A(3.0, 5.0);//用new动态开辟对象空间，初始化
4. 局部对象，静态对象，全局对象的构造函数调用：
- 局部对象每一次定义对象都需要调用
- 静态对象只在第一次定义史调用
- 全局对象在main函数之前调用
2.析构函数
在对象生命期结束时，析构函数回收系统为对象分配的空间
~类名(参数表)
1. 析构函数的特征：
- 无参
- 不可重载
- 无返回值
- 不指定类型
- 在撤消对象时由系统自动调用的
- 不显式定义时，系统会自动生成一个
2. 对象中使用new运算符创建空间需要使用显式定义析构函数，在函数体中使用delete运算符回收空间。
3. 当使用运算符delete删除一个由new动态产生的对象时，它首先调用该对象的析构函数，然后再释放这个对象占用的内存空间
4. 可以使用new建立对象数组
pa1=new A[3];
使用delete []pa1回收空间
3.调用顺序
全局对象：
局部对象
static局部对象：
new创建的对象：
4.拷贝构造函数
定义一个对象时，用另一个对象为其初始化
类名 :: 类名（类名 &对象名）
{
函数体
}
调用格式：
类名 对象1（对象2）
类名 对象1=对象2
没有定义显示定义拷贝构造函数时，系统会自动生成一个拷贝构造函数，将实参对象的所有成员数据一一复制到新对象：
类名（类名 &对象名）
{
成员数据1=对象名.成员数据1；
……
}
有时，自动生成的拷贝构造函数会出问题。
但是，当类中的数据成员中使用new运算符，动态地申请存储空间进行赋初值时，必须在类中显式地定义一个完成拷贝功能的构造函数，以便正确实现数据成员的复制。否则会出现两次回收同一段内存的错误，因为new运算符所开空间通过指针使用。
5.在A中含B的对象的构造函数
在b类中使用a类的对象，构造函数的格式
class a
{
public:
int a;char b
...
}
clas b
{
public:
int a;
a a1;
b(int a,char b, intc):a1(a,b){a=c}
}
静态成员与友元
通常，每当说明一个对象时，把该类中的有关成员数据拷贝到该对象中，即同一类的不同对象，其成员数据之间是互相独立的
1.静态成员数据
如果将类中的某一成员数据用static修饰，则这个成员数据会在编译时分配空间，该类所有的对象共享这块空间，即对于所有对象，该成员数据都是相同的，共享一块内存，所有对象都可以引用，公用的。
类的静态数据成员是静态分配存储空间的，而其它成员是动态分配存储空间的（全局变量除外）。当类中没有定义静态数据成员时，在程序执行期间遇到说明类的对象时，才为对象的所有成员依次分配存储空间，这种存储空间的分配是动态的；而当类中定义了静态数据成员时，在编译时，就要为类的静态数据成员分配存储空间。
- 静态成员受到访问权限约束，只有
public权限的静态成员数据才能在类外被访问。 - 静态成员数据必须 在类体外初始化，格式：
数据类型 类名::静态成员数据名 = 初值，不定义初值则默认为0 - 定义类以后，静态数据成员就可以被访问，不需要定义对象
- 使用作用域运算符
::调用，类名::静态成员数据名或对象名.静态成员数据名 - 静态成员数据可以在构造函数中赋初值，但是为了保证数据的一致性，一般是在定义性说明时赋初值。
2.静态成员函数
用static修饰成员函数
2. 与静态数据成员一样，在类外的程序代码中，通过类名加上作用域操作符，可直接调用静态成员函数。
- 静态成员函数只能直接使用本类的静态数据成员或静态成员函数，但不能直接使用非静态的数据成员 （可以引用使用）。这是因为静态成员函数可被其它程序代码直接调用，所以，它不包含对象地址的this指针。
- 静态成员函数的实现部分在类定义之外定义时，其前面不能加修饰词static。格式
5. 不能把静态成员函数定义为虚函数。
3.友元函数
1. 普通函数作为友元函数
友元函数是一种定义在类外部的普通函数，其特点是能够访问类中私有成员和保护成员，即类的访问权限的限制对其不起作用。
friend FuncName();
friend float Volume(A &a);
说明：
- 友元函数不是成员函数，是普通函数，没有
this指针。 - 友元函数可以无视访问权限的限制，访问类的所有数据成员。
2. 其他类的成员函数作为类的友元函数
A类中的某个成员函数是B类中的友元函数，这个成员函数可以直接访问B类中的私有数据。
注意：
- 此时，应先定义B再定义A
- 对于B中需要用到A中数据成员的函数，其在B中声明，在A的定义之后给出具体的函数体定义
- A需要在B之前做提前声明
class A;
class B
{
};
class A
{
...
friend 函数类型 B::成员函数名(参数)
...
};
例：
class A;
class B
{
double h;
public:
B(double h){h=high;}
void cal(A &c) //B中的成员函数z需要使用A中的数据成员
};
class A
{
double r;
public:
A(double a){r=a;}
friend void B::cal(A &c);//A的友元，B的成员函数，在A中只能给出声明
};
void B::cal(A &c) // A的友元，B的成员，在A、B之外给出完整定义
{
double v = 3.14*c.r*c.r*h
}
友元类
一个类的友元可以自由地用该类中的所有成员。
B是A的友元类，B可以使用A中的所有数据成员
class A
{
.....
friend class B;
}
一般先定义A，再定义B，但是B会在A之前先声明。
运算符重载
为了重载运算符，必须定义一个函数，并告诉编译器，遇到这个重载运算符就调用该函数，由这个函数来完成该运算符应该完成的操作。这种函数称为运算符重载函数，它通常是类的成员函数或者是友元函数。运算符的操作数通常也应该是类的对象。
规定：
- 只能重载已有的运算符
- 不是所有运算符都可以重载
- 重载运算符*不能改变操作数的个数
- 重载不能改变运算优先级
不能重载：?:(三目运算符) .(成员运算符) .*(成员指针) ::(作用域运算符) sizeof(字节个数运算符)
1.用成员函数重载
格式：
类名 operator<运算符>(<参数表>)
{ 函数体 }
A operator + (A &);
重新定义运算符，由左操作符调用右操作符。最后将函数返回值赋给运算结果的对象，没有返回值就为void类型。
2. 自增（自减）运算符重载：
前置：
operator ++( )
{ ......；}
后置：
operator ++(int)
{ ......；}
class A
{ float x, y;
public:
A(float a=0, float b=0){ x=a; y=b; }
A operator ++( ){A t; t.x=++ x; t.y=++y; return t;} //前置
A operator ++(int) { A t; t.x=x++; t.y=y++; return t;} //后置
};
void main(void)
{ A a(2,3), b;
b=++a;
b=a++;
}
调用格式：
b=a.operator++( );
b=++a;
注：成员函数实现运算符的重载时
- 运算符重载函数的参数只能有二种情况：没有参数或带有一个参数。对于只有一个操作数的运算符(如++)，在重载这种运算符时，通常不能有参数；而对于有二个操作数的运算符，只能带有一个参数。这参数可以是对象，对象的引用，或其它类型的参数。
- 运算符的左操作数为当前对象，并且要用到隐含的this指针。运算符重载函数不能定义为静态的成员函数，因为静态的成员函数中没有this指针。
2.用友元函数重载
所有参与运算的对象都作为参数，放入参数表
friend <类型说明> operator<运算符>(<参数表>)
{......}
friend A operator + (A &a, A &b)
{.....}
调用：
c=a+b;
// c = operat0r+(a,b)
重载自增自减运算符时，对于后置需要在参数表中加一个int参数，用以区分前置。当++或--后置时，则调用含有int的函数
注：=(赋值运算符),[](下标运算符),->(指针运算符)不可以用友元函数重载。
3.转换函数
不同类型的数据运算时的相互转换规则，只能用成员函数实现。
声明格式：
operator < type >( )
定义格式（不需要返回值）
ClassName :: operator ( )
A :: operator float ( )
- 转换函数必须是类的成员函数
- 转换函数的调用是隐式的
转换函数可以实现cout << 对象。
转换之后的数据如果支持某些运算符，则可以直接运算。
运算符调用顺序：
- 成员函数
- 非成员函数
- 转换后的类型是否支持该运算符
注：
- 转换函数只能是成员函数，不能是友元函数。
- 转换函数的操作数是对象。
- 转换函数可以被派生类继承，也可以被说明为虚函数。
4.重载赋值运算符
复合赋值运算符（+= -= *= /=）可以用成员函数或友元函数重载，赋值运算符（=）只能用成员函数重载。
1. 复合赋值运算符
声明格式：
返回值类型 operator+=(参数)
2. 赋值运算符
类名 &operator=(类名 &对象名)
{
成员数据1=对象名.成员数据1;
成员数据2=对象名.成员数据2;
...
成员对象n=对象名.成员数据n;
return *this;
}
5.perator 与&operator
简单来说就是operator 返回的是这个值，而&operator返回的是这个的地址（引用）。
主要的区别于用处就在于这个运算符的连用性，如果需要连用的话必须使用引用。
返回引用是为了能够连续赋值 如(a=b)=c，如果不返回引用的话像楼上说的那样，*this是当做临时变内量返回的容，C++为了保证临时变量从产生到返回不被修改，从而把临时变量定义为const，因而(a=b)=c的话，a=b为一个const，c是不能赋值给他的。
6.字符串类的重载
7.重载输入(提取)和输出(插入)运算符
1. 输入运算符(>>)
声明格式：
friend istream &operater>>(istream &, ClassName &);
返回类istream的引用，cin中可以连续使用运算符“>>”。
例：
istream &operator>>(istream &is, incount &cc)
{
is>>cc.c1>>cc.c2;
return is;
}
2. 输出运算符(<<)
声明格式：
friend ostream &operater<<(ostream &, ClassName &);
定义格式：
ostream &operator<<(ostream &os,incount &cc) //重载cout<<
{os<<"c1="<< cc.c1<<'\t'<<"c2="<< cc.c2<< endl; return os;}
返回值为is或os对象
继承与派生
在派生类中不可以定义基类的对象
三种访问权限：public,protected,private
1.单继承
class className: 访问权限 基类名
{
...
}
1. 公有派生(public)
访问权限变化：
| 成员属性 | 派生类中 | 派生类外 |
|---|---|---|
| 公有 | 可以访问 | 可以访问 |
| protected | 可以访问 | 不可以访问 |
| private | 不可以访问 | 不可以访问 |
class A { int x;
protected: int y;
public: int z;
A(int a,int b,int c){x=a;y=b;z=c;}//基类初始化
int Getx(){return x;}//返回x
int Gety(){return y;}//返回y
void ShowA(){cout<< "x="<class A
{
int x, y;
protected:
A(int a,int b){x=a;y=b;}
public:
void ShowA(){cout<< "x="<
class A
{
int x;
protected:
int y;
public:
int z;
A(int a,int b,int c){x=a;y=b;z=c;}
int Getx(){return x;}//返回x
int Gety(){return y;}//返回y
void ShowA(){cout<< "x="<
class A{ int x1,y1;
public: A(int a,int b) { x1=a; y1=b; }
void ShowA(void){ cout<<"A.x="< - 当基类有默认的构造函数或者没有定义构造函数，派生类的构造函数可以省略对接里构造函数的调用
- 基类构造函数使用1个或多个参数时，派生列必须定义构造函数，提供传参途径。
当撤销派生类对象时，析构函数的调用正好相反
3.继承的冲突与支配
1. 冲突
多继承时，可能出现派生类继承多个同名的数据成员或成员函数，需要使用类限定符区分：类::成员名;
例：
class A{
public: int x;
void Show(){cout <<"x="<
class A{
public: int x;
void Show(){cout <<"x="<class A
{
protected:
int x;
public: A(){x =1000;}
virtual void print(){ cout <<“x=”<print();//调用类A的虚函数
pa=&b; pa->print();//调用类B的虚函数
pa=&c; pa->print();}//调用类C的虚函数
说明：
- 当在基类中把成员函数定义为虚函数后，在其派生类中定义的虚函数必须与基类中的虚函数同名,参数的类型、顺序、参数的个数必须一一对应，函数的返回的类型也相同，才能为派生虚函数（由于函数重载）。
- 必须使用基类类型的指针变量，并使该指针指向不同的派生类对象，并通过调用指针所指向的虚函数才能实现动态的多态性。
- 在派生类中没有重新定义虚函数时，当调用这种派生类对象的虚函数时，则调用其基类中的虚函数。（虚函数可以继承）
- 可以把析构函数定义为虚函数，但不能把构造函数定义为虚函数。
- 一个函数如果被定义成虚函数，则不管经历多少次派生，仍将保持其虚特性，以实现一个接口，多个形态。
虚函数比一般的成员函数执行得慢
虚函数用基类指针调用才能体现多态性，用对象调用与一般成员函数无区别
2.纯虚函数
在基类中不对虚函数给出有意义的实现，它只是在派生类中有具体的意义。这时基类中的虚函数只是一个入口，具体的目的地由不同的派生类中的对象决定。
定义：
virtual 函数类型 函数名（参数表）= 0;
说明：
- 纯虚函数没有函数体，只有声明语句
- 拥有纯虚函数的基类不能定义对象，但可以定义指针和引用。
=0表示没有具体实现，在派生类中可以随便改写。
例：弦截法求解方程的根
# include
# include
using namespace std;
class root
{
double
}
3. 抽象类
至少包含一个纯虚函数的类。这种类只能作为派生类的基类，不能用来说明这种类的对象。
- 抽象类的纯虚函数可以是在抽象类中定义的，也可以是从抽象基类继承的。
- 抽象类不可以实例化，但可以定义指针和引用
- 不能用作函数参数类型、函数返回值类型或显示转换类型（不可实例化）
- 抽象类的派生类没有重载纯虚函数，给出函数实现，则该派生类仍为抽象类