面对对象编程总结（一）

一、面对对象编程介绍

面对过程程序 = 数据 + 算法

面对对象程序 = 对象 + 消息 （提高代码的维护性、复用性、扩展性、灵活性）

问题 1、面对对象的特点

* 抽象（代码的灵活性）
* 封装（代码的维护性）
* 继承（代码的复用性）
* 多态（代码的扩展性）

1、在C++中，主要用类来解决封装性



2、继承



3、多态



面对对象编程的优点



二、类与对象（类是对象的抽象，对象是类的实例化）

1、类的声明

class 类名

{

public：

共有成员（外部接口）

private：

私有成员；

protected：

保护成员

}；

在关键字public后面声明，它们是类与外部的接口，外部函数都可以访问共有类型数据和函数。

在private后面声明，只允许本类中的函数来访问，而外部的任何函数都不能来访问。

在关键字protected后面声明，与private类似，其差别表现在继承与派生时对派生类的影响不同。

2、成员函数

类外实现与类内实现成员函数，但类内实现的函数都是inline函数，占用内存。

什么是inline函数：编译时将所调用函数的代码直接嵌入到主调函数中,而不是将流程转出去。

以空间换执行时间。

3、类与结构的区别

在C++中，结构体几乎和类一样，也能放函数。

区别：

(1)class成员默认为private，struct 默认为public

(2)类的实例对象的大小由属性决定，也遵循内存的自对齐方式。

方法的空间是共享的。

4、对象的存储模型，什么是this指针，功能是什么？

this指针的解释：

1）一个对象的this指针并不是对象本身的一部分，不会影响sizeof（对象）的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。

2）this指针是类的一个自动生成、自动隐藏的私有成员，它存在于类的非静态成员函数中，指向被调用函数所在的对象。全局仅有一个this指针，当一个对象被创建时，this指针就存放指向对象数据的首地址。

this指针的通俗解释：

当你进入一个房子后，你可以看见桌子、椅子、地板等，但是房子你是看不到全貌了。对于一个类的实例来说，你可以看到它的成员函数、成员变量，但是实例本身呢？this是一个指针，它时时刻刻指向你这个实例本身。

为什么需要this指针？

因为this作用域是在类的内部，自己声明一个类的时候，还不知道实例化对象的名字，所以用this来使用对象变量的自身。在非静态成员函数中，编译器在编译的时候加上this作为隐含形参，通过this来访问各个成员（即使你没有写上this指针）。例如a.fun(1)<==等价于==>fun(&a,1)

this的使用：1)在类的非静态成员函数中返回对象的本身时候，直接用return *this(常用于操作符重载和赋值、拷贝等函数)。2)传入函数的形参与成员变量名相同时，例如：this->n = n (不能写成n=n)

//程序举例（转）
class Point

{
int x, y;

public:
Point(int a, int b) { x=a; y=b;}
Void MovePoint( int a, int b){ x+=a; y+=b;}
Void print(){ cout<<"x="< };

void main( )
{
Point point1( 10,10);
point1.MovePoint(2,2);
point1.print( );

}

a.对象point1调用MovePoint(2,2)的时候，即将point1对象的地址传递给了this指针

b.编译器编译后的原型应该是void MovePoint(Point *this, int a, int b)

c.在函数体中可以写成{this->x += a; this->y += b;}

d.也等价为point1.x += a；point1.y += b。(指针变量通过->访问成员变量(函数)，对象通过.)

5、类的作用域

前向声明的类不能实例化，在类中只能定义类的对象指针和引用。

6、嵌套类和局部类

嵌套类是在类里面再定义一个类

局部内在函数体内定义，局部类不能有静态成员和方法，必须在类内实现方法。

三、构造函数与析构函数

1、构造函数

什么是构造函数？构造函数是特殊的成员函数，创建类型的新的对象，系统会自动调用构造函数，构造函数是为了保证对象的每个数据成员都能被正确初始化。

构造函数的特点：

（1）函数名和类名完全相同。

（2）构造函数不能定义返回类型，不能有返回值，也不能使用void。

（3）通常情况下构造函数应声明为公有函数，否则不能像其他成员函数被显式的调用。

（4）构造函数被声明为私有有特殊的用途

（5）构造函数可以重载

什么是默认构造函数（不带参数的构造函数）

全局对象的构造函数现于main函数执行

构造函数与new运算符？

/*使用NEW运算符在堆中开辟一块新空间，例程如下：
#include <iostream>
using std::cout;
class A
{
public:
A(){cout<<"构造函数执行完毕\n";};

};
int main()
{
A *p;     //声明一个属于A类的指针p
p=new A; //使用new运算符创建一块堆中空间，它的大小由类A的数据成员的类型和数量来定，由于堆在内存中都是匿名的，因此这里没有为它命名，只是将它的内存地址赋给了指针p
return 0;
}
*/
//使用new运算符创建并实例化一个对象，例程如下：
#include <iostream>
using std::cout;
class A
{
public:
A(int a,int b){i=a;j=b;cout<<"构造函数执行完毕\n";};
void print(){cout<<i*j<<"\n";}
void set(int a,int b){i=a;j=b;}
private:
int i,j;
};
int main()
{
A *p=new A(1,2); //在创建一个对象的同时实例化它的数据成员
p->print();   //输出结果
p->set(7,8);   //利用成员函数访问该对象的数据成员并赋值
p->print();   //输出结果
return 0;
}

使用new运算符建立一个类的对象时，比如说类A的对象，new首先分配足以保证该类的一个对象所需要的内存，然后自动调用构造函数来初始化这块内存，再返回这个对象的地址。

2、析构函数

什么时候析构函数？

析构函数的特点

（1）函数名与类名相识（前面带~）

（2）没有返回类型

（3）析构函数不能重载

（4）系统会默认生成一个析构函数

析构函数与数组的得出构造函数与析构函数的调用顺序相反。

以new创建的对象，通delete才能触发析构函数。

构造函数详解

* 转换构造函数

什么是转转换构造函数?

单个参数的构造函数。是将其他类型转换为类类型。但只有一个参数是非常危险的，因为编译器可以使用这种函数把参数的类型隐式转换为类类型。

//不带参数的构造函数为默认构造函数
Test::Test()
{
num_ = 0;
}

//转换构造函数
Test::Test(int num)
{
num_ = num;

}

int main()
{
Test t(10);//带一个参数的构造函数，充当的是普通构造函数的功能
t = 20;//将20这个整数赋值给t这个对象。
//1.调用转换构造函数将20这个整数转换为类类型。（生成一个临时对象）
//2.将临时对象赋值给t对象（调用的是=运算符）
return 0;
}

* 赋值与初始化的区别

Test t = 5;//初始化

Test t;

t = 5;//赋值

在初始化语句中等号不是运算符。编译器对这种表述方法有特殊的解释。

赋值：Test & Test::operator=(const & Test & other);

explicit

explicit关键字的作用：编译器不会把声明为explicit的构造函数用于隐式转换，它只能在程序代码中显示创建对象。

构造函数初始化列表

class Object
{
public:
Object(int num = 0):num_(num),knum_(num)
{

private:
int num_;
int knum_;
};

构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如：

class CExample
{

public:
int a;
float b;
//构造函数初始化列表
CExample(): a(0),b(8.8)
{
}
//构造函数内部赋值
CExample()
{
a=0;
b=8.8;
}

};

上面的例子中两个构造函数的结果是一样的。上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化列表的构造函数是对类的成员赋值，并没有进行显式的初始化。

初始化和赋值对内置类型的成员没有什么大的区别，像上面的任一个构造函数都可以。对非内置类型成员变量，为了避免两次构造，推荐使用类构造函数初始化列表。但有的时候必须用带有初始化列表的构造函数：

1.成员类型是没有默认构造函数的类。若没有提供显示初始化式，则编译器隐式使用成员类型的默认构造函数，若类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。

2.const成员或引用类型的成员。因为const对象或引用类型只能初始化，不能对他们赋值。

初始化数据成员与对数据成员赋值的含义是什么？有什么区别？

首先把数据成员按类型分类并分情况说明:

1.内置数据类型，复合类型（指针，引用）

在成员初始化列表和构造函数体内进行，在性能和结果上都是一样的

2.用户定义类型（类类型）

结果上相同，但是性能上存在很大的差别。因为类类型的数据成员对象在进入函数体前已经构造完成，也就是说在成员初始化列表处进行构造对象的工作，调用构造函数，在进入函数体之后，进行的是对已经构造好的类对象的赋值，又调用个拷贝赋值操作符才能完成（如果并未提供，则使用编译器提供的默认按成员赋值行为）

Note:

初始化列表的成员初始化顺序:

C++初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

Example:
class CMyClass
{

CMyClass(int x, int y);
int m_x;
int m_y;
};

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y)
{
}

你可能以为上面的代码将会首先做m_y=I，然后做m_x=m_y，最后它们有相同的值。但是编译器先初始化m_x，然后是m_y,，因为它们是按这样的顺序声明的。结果是m_x将有一个不可预测的值。有两种方法避免它，一个是总是按照你希望它们被初始化的顺序声明成员，第二个是，如果你决定使用初始化列表，总是按照它们声明的顺序罗列这些成员。这将有助于消除混淆。

必须使用初始化列表的初始化：

（1）成员对象

（2）const成员

（3）引用成员。

原因如下：

1.成员类型是没有默认构造函数的类。若没有提供显示初始化式，则编译器隐式使用成员类型的默认构造函数，若类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。

2.const成员或引用类型的成员。因为const对象或引用类型只能初始化，不能对他们赋值。

对象成员及其初始化

对象成员（对象所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行

枚举适用于所有对象

拷贝构造函数总结

作用：作用：使用一个已经存在的对象来初始化一个新的同一类的对象

声明：只有一个参数并且参数为该类对象的引用。

Test::Test(const Test & other):num(other.num_)
{
num_ = other.num_;
}

拷贝函数三种调用情况：

1、用已有的对象去初始化对象

2、当函数的形参是类的对象，调用函数

3、当函数的返回值是类对象，函数执行完成返回调用者时使用

深拷贝与浅拷贝

在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

禁止拷贝：

对于读一无二的对象禁止拷贝，将拷贝函数私有化。

代码

#ifndef _TEST_H_
#define _TEST_H_
class CA
{
public:
CA();
CA(int b,char *cstr);
~CA();
CA(const CA & other);
void Display();
private:
int a_;
char *str_;
};
#endif
#include "Test.h"
#include <iostream>
#include <string.h>
using namespace std;
CA::CA()
{
}
CA::CA(int b,char *cstr)
{
a_ = b;
str_ = new char [b];
strcpy(str_,cstr);
}
CA::CA(const CA & other)
{
a_= other.a_;
str_ = new char [a_];
if(str_ != NULL)
{
strcpy(str_,other.str_);
}
}
CA::~CA()
{
delete str_;
}
void CA::Display()
{
cout << str_ << endl;
}

#include <iostream>
#include "Test.h"
using namespace std;
int main()
{
CA A(10,"hello");
CA B = A;
B.Display();
return 0;
}

空类默认生成的成员