C++讲义 第5章 类与对象

《C++程序设计》教学讲义5章

第5章 类与对象
§5.1 面向对象三要素
封装，继承，多态
封装在C语言中用结构体实现
封装在C++中用类实现
类是一种自定义数据类型
§5.2 类的定义
引例：
#include <iostream>
using namespace std;
//类的定义
class Clock
{
public:
    void ShowTime();
    void SetTime(int NewH=0, int NewM=0, int NewS=0);
private:
    int m_Hour;
    int m_Minute;
    int m_Second;
};
//类成员函数实现
void Clock::ShowTime()
{
cout<<m_Hour<<":"<<m_Minute<<":"<<m_Second<<endl;
}
//类成员函数实现
void Clock::SetTime(int NewH, int NewM, int NewS)
{
m_Hour = NewH; m_Minute = NewM; m_Second = NewS;
}

int main()
{
Clock a;//类对象声明
a.SetTime(12, 30, 0);
a.ShowTime();
return 0;
}

语法：

class 类名称
{
public:
    外部接口;
protected:
    保护型成员;
private:
    私有成员;
};

§5.3 对象
声明：
类名 对象名;
调用：
对象名.公有成员函数名(形参列表);

§5.4 类的构造函数与析构函数

§5.4.1 构造函数与析构函数作用
构造函数：对类对象初始化。
析构函数：释放类对象。

§5.4.2 构造函数与析构函数写法
引例：
class Clock
{
public:
Clock();
~Clock();
};

Clock::Clock()
{

}

Clock::~Clock()
{

}
构造函数特点：
1、无返回值
2、函数名与类名相同
析构函数特点：
1、无返回值
2、函数名为：~类名

§5.4.3 类的默认构造函数
引例：
#include <iostream>
using namespace std;

class Clock
{
public:
Clock();
};

Clock::Clock()
{
cout<<"默认构造函数被调用"<<endl;
}

int main()
{
Clock a;//调用默认构造函数
return 0;
}

§5.4.4 带参数的构造函数
引例：
#include <iostream>
using namespace std;

class Clock
{
public:
Clock();
Clock(int h, int m, int s);
};

Clock::Clock()
{
cout<<"默认构造函数被调用"<<endl;
}

Clock::Clock(int h, int m, int s)
{
cout<<"带参数的构造函数被调用"<<endl;
}

int main()
{
Clock a;//调用默认构造函数
Clock b(0, 0 ,0);//调用带参数的构造函数
return 0;
}

§5.5 内联函数
表现形式1：
#include <iostream>
using namespace std;

class CA
{
public:
//外联函数
void SetValue(int a);
//内联函数
int GetValue()
{
   return m_a;
}
private:
int m_a;
};

void CA::SetValue(int a)
{
m_a = a;
}

int main()
{
CA ca;
ca.SetValue(5);
cout<<"m_a = "<<ca.GetValue()<<endl;
return 0;
}

表现形式2 
利用关键字inline：

#include <iostream>
using namespace std;

class CA
{
public:
//外联函数
void SetValue(int a);
//内联函数
inline int GetValue();
private:
int m_a;
};

void CA::SetValue(int a)
{
m_a = a;
}

inline int CA::GetValue()
{
return m_a;
}

int main()
{
CA ca;
ca.SetValue(5);
cout<<"m_a = "<<ca.GetValue()<<endl;
return 0;
}

§5.6 成员函数重载
引例：
#include <iostream>
using namespace std;

class CA
{
public:
int Add(int x, int y);
int Add(int x, int y, int z);
double Add(double x, double y); 
};

int CA::Add(int x, int y)
{
return (x+y);
}

int CA::Add(int x, int y, int z)
{
return (x+y+z);
}

double CA::Add(double x, double y)
{
return (x+y);
}

int main()
{
CA a;
cout<<"1+2 = "<<a.Add(1, 2)<<endl;
cout<<"1+2+3 = "<<a.Add(1, 2, 3)<<endl;
cout<<"1.2+2.3 = "<<a.Add(1.2, 2.3)<<endl;
return 0;
}

§5.7 成员函数的默认值
引例：
#include <iostream>
using namespace std;

class CA
{
public:
int Add(int x, int y=0, int z=0); 
};

int CA::Add(int x, int y/* =0 */, int z/* =0 */)
{
return (x+y+z);
}

int main()
{
CA a;
cout<<"1+0+0 = "<<a.Add(1)<<endl;
cout<<"1+2+0 = "<<a.Add(1,2)<<endl;
cout<<"1+2+3 = "<<a.Add(1,2,3)<<endl;
return 0;
}

§5.8 类的静态成员
§5.8.1 静态数据成员
引例：
#include <iostream>
using namespace std;

class CA
{
public:
static int GetValue();
static void SetValue(int x);
private:
static int m_a;
};

//静态数据成员初始化
int CA::m_a = 0;

int CA::GetValue()
{
return m_a;
}

void CA::SetValue(int x)
{
m_a = x;
}

int main(void)
{
CA::SetValue(5);
cout<<CA::GetValue()<<endl;
return 0;
}

概述:
关键字：static
含义：
静态成员属于整个类共有，它不属于任何一个具体的对象。
静态成员具有静态周期。
用法：“类名::标识符”

§5.8.2 静态函数成员
记住：
静态成员函数可以直接访问该类的静态数据和静态函数；
而访问非静态数据成员必须通过参数传递方式得到对象名，然后通过对象名来访问。
例子：
#include <iostream>
using namespace std;

class CA
{
public:
static void fun(CA &a);
private:
int m_x;
};

void CA::fun(CA &a)
{
a.m_x = 0;
cout<<"a.m_x = "<<a.m_x<<endl;
}

int main()
{
CA a;
a.fun(a);
return 0;
}

§5.9 友元函数和友元类
§5.9.1 概述
友元关系：可访问类的私有或被保护成员；
友元关系是单向关系；
友元关系不能被继承。
关键字：friend
注意：不建议使用
§5.9.2 友元函数
引例：
#include <iostream>
using namespace std;

class CA
{
public:
friend void Fun(CA &a);
private:
int m_a;
};

void Fun(CA &a)
{
cout<<"a.m_a = "<<a.m_a<<endl;
}

int main()
{
CA a;
Fun(a);
return 0;
}

§5.9.2 友元类
引例：
#include <iostream>
using namespace std;

class CA
{
public:
friend class CB;
private:
int m_a;
};

class CB
{
public:
void Fun();
private:
CA m_b;
};

void CB::Fun()
{
cout<<"m_b.m_a = "<<m_b.m_a<<endl;
}

int main()
{
CB b;
b.Fun();
return 0;
}