『C++学习录』类与对象

楔子：D

七月燃尽了
要花枝招展地丰富起来！

类与对象

类与对象A

一、OOP基本手段

1.抽象

属性抽象——类中的数据成员

行为（操作）抽象——类中的成员函数

封装（定义class）产生类，类实例化产生类的实体——对象

2.封装

属性

方法——接口

class Clock
{
//外部接口
public:
	void SetTime(int NewHour,int NewMin,int NewSec);//成员函数
	void ShowTime(void);//成员函数
//内部属性
private:
	int Hour;//成员变量
	int Minute;//成员变量
	int Second;//成员变量
//内部行为
	void Run(void);//成员函数
};

3.继承与派生

支持分类层次，定义新的类

继承通过派生来实现

4.多态性

类的派生过程，允许不同派生类对同一个操作有不同行为实现

虚函数与重写函数（override）实现

类与对象B

二、类

1.类的声明形式

（类似struct)

class name

{

public:

private:

protected:

}

2.类成员的访问类型

1)public

定义类的外部接口

2)private

定义内部数据和代码实现

#无关键字声明时，class内的成员都是Private类型

3)protected

本类或派生类对象成员函数被访问，不允许外部访问

3.类的定义

void Clock :: SetTime()

{

}

void Clock :: ShowTime()

{

}

4.类成员的定义

内联成员函数在编译时不再控制转移

class Point
{
	public:
		void Init(int initX,int initY)
		{
			X = initX;
			Y = initY;
		};
		int GetX(){return X};
		int GetY(){return Y};
	private:
		int X,Y;
}
/*-----------------------------------------------------------------------------------------------*/
class Point
{
	public:
		void Init(int initX,int initY);
		int GetX();
		int GetY();
	private:
		int X,Y;	
}

inline void Point :: Init(int initX,int initY)
		{
			X = initX;
			Y = initY;
		}
inline int Point :: GetX()
{
	return X;
}
inline int Point :: GetY()
{
	return Y;
}

5.对象

1）声明形式

类名 对象名

Clock MyClock

2）对象成员的访问方式

对象名.成员名

MyClock.ShowTime();//访问成员函数

MyClock.Hour = 12;//访问成员函数（公有类型才可以直接访问）

#Attention

1)从类的外部访问，受到访问类型限制（public/private/protected)

2)从同一个对象的成员函数访问本对象成员，可以省略对象名，直接采用成员名

6.类中的自引用

关键字this:指向被调用的对象的指针

this是类成员函数的一个隐含参数

7.类的概念结构

c++类是定义抽象数据结构

数据+方法

属于一个类的所有实例（对象）有相同的结构

调用一个对象的方法，操作访问目标为本对象的数据成员。（this)

类与对象C

8.类的构造函数

构造函数：对象数据初始化

构造函数没有返回值（不是返回void)

1）构造函数

class Clock
{
public:
	Clock(int Hour,int Min,int Sec);//构造函数，与类的名字相同，无返回值
	...
private:
	int Hour,int Minute,int Second;
};

//构造函数无返回值
Clock::Clock(int Hour,int Min,int Sec)//类的名字(Clock)+限定符(::)+构造函数名字(Clock)
{
	this->Hour = Hour;//私有成员进行初始化赋值
	Minute = Min;
	Second = Sec;
}

int main()
{
	Clock MyClock(0,0,0);//调用构造函数，初始化MyClock
	MyClock.ShowTime();
	return 0;	
}

2）构造函数的重载

class Clock
{
public:
	Clock();//无参数的构造函数
	Clock(int Hour,int Min,int Sec);//构造函数，与类的名字相同，无返回值
	...
private:
	int Hour,int Minute,int Second;
};

//构造函数
Clock::Clock()
{
	Hour = Minute = Second = 0;
}

//构造函数无返回值
Clock::Clock(int Hour,int Min,int Sec)//类的名字(Clock)+限定符(::)+构造函数名字(Clock)
{
	this->Hour = Hour;//私有成员进行初始化赋值
	Minute = Min;
	Second = Sec;
}

int main()
{
	Clock MyClock(0,0,0);//调用第二个构造函数，初始化MyClock
	Clock MyClock2;//调用第一个无参数的构造函数
	return 0;	
}

3）拷贝构造函数

a)形参为本类对象的引用

class 类名

{
public:
	类名（类名&对象名）;
	...
}

b)拷贝构造函数的引用

缺省拷贝构造函数(未声明编译器自动生成)

...
Point::Point(Point& p)//拷贝构造函数
{
	X = p.x;
	Y = p.y;
	cout<<"Copy Constructor"<<endl;
}

void func1(Point p)
{
	cout<<p.GetX()<<endl;
}

Point func2()
{
		Point A(1,2);
		return A;//函数返回值是类对象，调用拷贝构造函数
}//函数结束时A生命期结束，但系统会产生临时对象以供后续调用，之后再释放掉

int main()
{
	Point A(1,2);//初始化
	Point B(A);//对象A初始化B，调用拷贝构造函数
	func1(A);//类对象作为函数形参，调用拷贝构造函数
	Point C = func2();//函数返回值为类对象，调用拷贝构造函数
}

9.析构函数

对象被删除/生命期结束前调用该函数

形式：~类名();

...
class DataFile
{
	private:
		File * fPtr;
		char * FileBuf;
	public:
		DataFile(char * FileName);//构造函数
		DataFile(DataFile& DF);//拷贝构造函数
		~DataFile();//析构函数
//其他函数
	void ReadFile();
	...
}
//构造函数
DataFile::DataFile(char * FileName)
{
	fPtr = fopen(FileName,"rb");
	FileBuf = new char [BUF_SIZE];
}
//拷贝构造函数
DataFile::DataFile(DataFile& DF)
{
	fPtr = DF.fPtr;
	FileBuf = new char [BUF_SIZE];
}
//析构函数
DataFile::~DataFile()
{
	fclose(fPtr);
	delete [] FileBuf;
}

#define MAX_STR_LEN 1024
class CMyString
{
private:
	int iStrLen;
	char * pStrBuf;
	...
public:
	CMyString();
	CMyString(char * pStr);
	~CMyString();
	
	CopyString(char * pSource);
};
CMyString::CMyString():iStrLen(0)//函数不带参数，参数列表
{
	pStrLen = new char[MAX_STR_LEN];
	pStrLen[0] = 0;
}
CMyString::CMyString(char * pStr)
{
	pStrLen = new char[MAX_STR_LEN];
	CopyString(pStr);
}
CMyString::CopyString(char * pSource)
{
	::strcpy(pStrBuf,pSource);
	iStrLen = ::strlen(pSource);
}
CMyString::~CMyString()//析构函数
{
	delete [] pStrLen;
}

10.类的组合

一个类内嵌其他类的对象作为成员

1）组合类（包含与被包含）

class Point
{

}

class Line
{
private：
	Point p1,p2;//两个端点
public:
	Line(Point a,Point b);//构造函数
	
	void Draw(void);//画线段
};

2）类组合的构造函数

声明形式

类名::类名（参数表）
	:成员（初始化参数），成员（初始化参数），...
{
	本类初始化
}

//对p1p2调用默认构造函数Point()
Line::Line()
{
...
}
//对p1调用构造函数Point(h,v),对p2调用默认构造函数Point()
Line::Line(int x1,int y1) : p1(x1,y1)
{
...
}
//对p1p2调用构造函数Point(h,v)，用w初始化成员width
Line::Line(int x1,int y1,int x2,int y2,int w)
:p1(x1,y1),p2(x2,y2),width(w)
{
...
}
//对p1p2调用构造函数Point(p)
Line::Line(Point a,Point b,int w)
:p1(a),p2(b),width(w)
{
...
}

尾巴：D

不要怠惰不要怠惰！！！