二、基础篇
三、封装篇
练习题1.
定义一个Student类，包含名字和年龄两个数据成员，实例化一个Student对象，并打印出其成两个数据成员.
#include <iostream>
#include <string>
using namespace std;
/**
* 定义类：Student
* 数据成员：名字、年龄
*/
class Student
{
public:
// 定义数据成员名字 m_strName 和年龄 m_iAge
string m_strName;
int m_iAge;
};
int main()
{
// 实例化一个Student对象stu
Student stu;
// 设置对象的数据成员
stu.m_strName = "慕课网";
stu.m_iAge = 2;
// 通过cout打印stu对象的数据成员
cout << stu.m_strName << " " << stu.m_iAge << endl;
return 0;
}
练习题2.
定义一个Student类，包含名字一个数据成员，使用getName和setName函数封装名字这个数据成员。在main函数中通过new实例化对象，并打印其相关函数。
#include <iostream>
#include <string>
using namespace std;
/**
* 定义类：Student
* 数据成员：m_strName
* 数据成员的封装函数：setName()、getName()
*/
class Student
{
public:
// 定义数据成员封装函数setName()
void setName(string name)
{
m_strName = name;
}
// 定义数据成员封装函数getName()
string getName()
{
return m_strName;
}
private:
//定义Student类私有数据成员m_strName
string m_strName;
};
int main()
{
// 使用new关键字，实例化对象
Student *stu = new Student();
// 设置对象的数据成员
stu->setName("慕课网");
// 使用cout打印对象str的数据成员
cout<< stu->getName()<<endl;
// 将对象str的内存释放，并将其置空
delete stu;
stu = NULL;
return 0;
}
练习题3.
定义一个Student类，包含名字一个数据成员，定义无参构造函数、有参构造函数、拷贝构造函数、析构函数及对于名字的封装函数，在main函数中实例化Student对象，并访问相关函数，观察运行结果。
#include <iostream>
#include <string>
using namespace std;
/**
* 定义类：Student
* 数据成员：m_strName
* 无参构造函数：Student()
* 有参构造函数：Student(string _name)
* 拷贝构造函数：Student(const Student& stu)
* 析构函数：~Student()
* 数据成员函数：setName(string _name)、getName()
*/
class Student {
public:
string m_strName;
void setName(string _name){
m_strName = _name;
};
string getName(){
return m_strName;
}
// 无参构造函数：Student()
Student(){
}
// 有参构造函数：Student(string _name)
Student(string _name){
m_strName = _name;
}
// 拷贝构造函数：Student(const Student& stu)
Student(const Student &stu);
// 析构函数：~Student()
~Student(){
cout<<"析构函数"<<endl;
}
};
int main(void)
{
// 通过new方式实例化对象*stu
Student *stu = new Student();
// 更改对象的数据成员为“慕课网”
stu->setName("慕课网");
// 打印对象的数据成员
cout<<stu->getName()<<endl;
return 0;
}
3.2封装篇（下）
3.2.2 对象成员与对象数组
练习题2-9.
定义具有2个对象的Coordinate数组，遍历对象数组，打印对象信息
结果如图所示
(1,2)
(3,4)
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate()
{
}
// 打印坐标的函数
void printInfo()
{
cout << "(" << m_iX << "," << m_iY << ")" << endl;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
//定义对象数组
Coordinate *coorArr = new Coordinate[2];
//遍历数组
for(int i = 0; i < 2; i++)
{
if (i == 0) {
coorArr[i].m_iX = 1;
coorArr[i].m_iY = 2;
}else{
coorArr[i].m_iX = 3;
coorArr[i].m_iY = 4;
}
}
//遍历数组，打印对象信息
for(int i = 0; i < 2; i++)
{
coorArr[i].printInfo();
}
return 0;
}
3.2.3 深拷贝与浅拷贝
3.2.4 对象指针
练习题4-3.
定义一个坐标类，在堆上实例化坐标对象，并给出坐标（3，5），然后打印坐标信息，销毁坐标对象。
结果如图：(3,5)
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate(int x, int y)
{
// 设置X,Y的坐标
m_iX = x;
m_iY = y;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
// 在堆上创建对象指针
Coordinate *p = new Coordinate(3, 5);
// 打印坐标
cout << "(" << p->m_iX << "," << p->m_iY << ")" << endl;
// 销毁对象指针
delete p;
p = NULL;
return 0;
}
3.2.5 const再现江湖
练习题5-6.
定义一个坐标类，在栈上实例化坐标类常对象，并给出坐标（3，5），然后定义常引用、常指针，最后使用对象、引用、指针分别通过调用信息打印函数打印坐标信息。
打印结果如图
(3,5)
(3,5)
(3,5)
#include <iostream>
using namespace std;
class Coordinate
{
public:
Coordinate(int x, int y)
{
// 设置X,Y的坐标
m_iX = x;
m_iY = y;
}
// 实现常成员函数
void printInfo() const
{
cout << "(" << m_iX << "," << m_iY << ")" << endl;
}
public:
int m_iX;
int m_iY;
};
int main(void)
{
const Coordinate coor(3, 5);
// 创建常指针p
const Coordinate *p = &coor;
// 创建常引用c
const Coordinate &c = coor;
coor.printInfo();
p->printInfo();
c.printInfo();
return 0;
}
四、继承篇
练习题3-6.
定义两个类，人类中含有数据成员姓名（m_strName）及成员函数eat()
士兵类从人类派生，含有数据成员编号（m_strCode)及成员函数attack()
在main函数通过对数据的访问，体会公有继承的语法特点。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义人的类: Person
* 数据成员姓名: m_strName
* 成员函数: eat()
*/
class Person
{
public:
string m_strName;
void eat()
{
cout << "eat" << endl;
}
};
/**
* 定义士兵类: Soldier
* 士兵类公有继承人类: public
* 数据成员编号: m_strCode
* 成员函数: attack()
*/
class Soldier:public Person
{
public:
string m_strCode;
void attack()
{
cout << "fire!!!" << endl;
}
};
int main(void)
{
// 创建Soldier对象
Soldier soldier;
// 给对象属性赋值
soldier.m_strName = "Jim";
soldier.m_strCode = "592";
// 打印对象属性值
cout << soldier.m_strName << endl;
cout << soldier.m_strCode << endl;
// 调用对象方法
soldier.eat();
soldier.attack();
return 0;
}
练习题4-7.【继承中的特殊关系】
定义两个类，基类是人类，定义数据成员姓名（name），及成员函数void attack()。
士兵类从人类派生，定义与人类同名的数据成员姓名（name）和成员函数void attack()。
通过对同名数据成员及成员函数的访问理解成员隐藏的概念及访问数据的方法。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义人类: Person
* 数据成员: m_strName
* 成员函数: attack()
*/
class Person
{
public:
string m_strName;
void attack()
{
cout << "attack" << endl;
}
};
/**
* 定义士兵类: Soldier
* 士兵类公有继承人类
* 数据成员: m_strName
* 成员函数: attack()
*/
class Soldier: public Person
{
public:
string m_strName;
void attack()
{
cout << "fire!!!" << endl;
}
};
int main(void)
{
// 实例士兵对象
Soldier soldier;
// 向士兵属性赋值"tomato"
soldier.m_strName = "tomato";
// 通过士兵对象向人类属性赋值"Jim"
soldier.Person::m_strName = "Jim";
// 打印士兵对象的属性值
cout << soldier.m_strName << endl;
// 通过士兵对象打印人类属性值
cout << soldier.Person::m_strName << endl;
// 调用士兵对象方法
soldier.attack();
// 通过士兵对象调用人类方法
soldier.Person::attack();
return 0;
}
练习题5-5.【多继承与多重继承】
定义worker工人类及children儿童类
worker类中定义数据成员m_strName姓名
children类中定义成员m_iAge年龄
定义ChildLabourer童工类,公有继承工人类和儿童类
在main函数中通过new实例化ChildLabourer类的对象，并通过该对象调用worker及children类中的成员函数，最后销毁该对象，体会多继承的继承特性及构造函数及析构函数的执行顺序。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义工人类: Worker
* 数据成员: m_strName
* 成员函数: work()
*/
class Worker
{
public:
Worker(string name)
{
m_strName = name;
cout << "Worker" << endl;
}
~Worker()
{
cout << "~Worker" << endl;
}
void work()
{
cout << m_strName << endl;
cout << "work" << endl;
}
protected:
string m_strName;
};
/**
* 定义儿童类: Children
* 数据成员: m_iAge
* 成员函数: play()
*/
class Children
{
public:
Children(int age)
{
m_iAge = age;
cout << "Children" << endl;
}
~Children()
{
cout << "~Children" << endl;
}
void play()
{
cout << m_iAge << endl;
cout << "play" << endl;
}
protected:
int m_iAge;
};
/**
* 定义童工类: ChildLabourer
* 公有继承工人类和儿童类
*/
class ChildLabourer : public Worker, public Children
{
public:
ChildLabourer(string name, int age):Worker(name),Children(age)
{
cout << "ChildLabourer" << endl;
}
~ChildLabourer()
{
cout << "~ChildLabourer" << endl;
}
};
int main(void)
{
// 使用new关键字创建童工类对象
ChildLabourer *child = new ChildLabourer("DevHank", 28);
// 通过童工对象调用父类的work()和play()方法
child->work();
child->play();
// 释放
delete child;
child = NULL;
return 0;
}
练习题6-4.【虚继承】
定义Person人类，worker工人类及children儿童类，
worker类中定义数据成员m_strName姓名，
children类中定义成员m_iAge年龄，
worker类及children类均虚公有继承Person类，
定义ChildLabourer童工类，公有继承工人类和儿童类，从而形成菱形继承关系
在main函数中通过new实例化ChildLabourer类的对象，并通过该对象调用Person，Worker及Children类中的成员函数，最后销毁该对象，掌握多重继承，多继承，虚继承的定义方法。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义人类: Person
*/
class Person
{
public:
Person()
{
cout << "Person" << endl;
}
~Person()
{
cout << "~Person" << endl;
}
void eat()
{
cout << "eat" << endl;
}
};
/**
* 定义工人类: Worker
* 虚继承人类
*/
class Worker : virtual public Person
{
public:
Worker(string name)
{
m_strName = name;
cout << "Worker" << endl;
}
~Worker()
{
cout << "~Worker" << endl;
}
void work()
{
cout << m_strName << endl;
cout << "work" << endl;
}
protected:
string m_strName;
};
/**
* 定义儿童类:Children
* 虚继承人类
*/
class Children : virtual public Person
{
public:
Children(int age)
{
m_iAge = age;
cout << "Children" << endl;
}
~Children()
{
cout << "~Children" << endl;
}
void play()
{
cout << m_iAge << endl;
cout << "play" << endl;
}
protected:
int m_iAge;
};
/**
* 定义童工类：ChildLabourer
* 公有继承工人类和儿童类
*/
class ChildLabourer: public Worker, public Children
{
public:
ChildLabourer(string name, int age):Worker(name), Children(age)
{
cout << "ChildLabourer" << endl;
}
~ChildLabourer()
{
cout << "~ChildLabourer" << endl;
}
};
int main(void)
{
// 用new关键字实例化童工类对象
ChildLabourer *p = new ChildLabourer("DevHank", 18);
// 调用童工类对象各方法。
p->eat();
p->work();
p->play();
delete p;
p = NULL;
return 0;
}
五、多态篇
练习题2-11.【虚析构函数】
定义一个动物（animal）类，要求含有虚函数eat和move，并定义构造函数和虚析构函数
定义一个狗（Dog）类，要求共有继承动物类，定义构造函数和虚析构函数，并实现自己的eat和move函数
使用父类对象实例化子类，调用子类成员函数
在代码编辑器中，填写相应的代码，是代码的运行结果如下所示
Animal
Dog
Dog -- eat
Dog -- move
~Dog
~Animal
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义动物类：Animal
* 成员函数：eat()、move()
*/
class Animal
{
public:
// 构造函数
Animal(){cout << "Animal" << endl;}
// 析构函数
virtual ~Animal(){cout << "~Animal" << endl;}
// 成员函数eat()
virtual void eat(){cout << "Animal -- eat" << endl;}
// 成员函数move()
virtual void move(){cout << "Animal -- move" << endl;}
};
/**
* 定义狗类：Dog
* 此类公有继承动物类
* 成员函数：父类中的成员函数
*/
class Dog : public Animal
{
public:
// 构造函数
Dog(){cout << "Dog" << endl;}
// 析构函数
virtual ~Dog(){cout << "~Dog" << endl;}
// 成员函数eat()
virtual void eat(){cout << "Dog -- eat" << endl;}
// 成员函数move()
virtual void move(){cout << "Dog -- move" << endl;}
};
int main(void)
{
// 通过父类对象实例化狗类
Animal *dog = new Dog();
// 调用成员函数
dog->eat();
dog->move();
// 释放内存
delete dog;
dog = NULL;
return 0;
}
练习题3-4.【纯虚函数】
定义一个动物（animal）类，要求含有虚函数eat和纯虚函数move以及数据成员m_strName，并定义构造函数和虚析构函数
定义一个狗（Dog）类，要求公有继承动物类，定义构造函数和虚析构函数，并实现自己的eat和move函数
通过动物类实例化狗类，调用狗类当中的成员函数
任务:在代码编辑器中，填写相应代码，使输出结果如下图所示
Dog
Dog--狗类 -- eat
Dog--狗类 -- move
~Dog
~Animal
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义动物类：Animal
* 虚函数：eat()
* 纯虚函数：move()
* 数据成员：m_strName
*/
class Animal
{
public:
// 默认构造函数
Animal(){}
// 含参构造函数
Animal(string name){m_strName = name; cout << "Animal" << endl;}
// 虚析构函数
virtual ~Animal(){cout << "~Animal" << endl;}
// 虚成员函数
virtual void eat(){cout << "Animal--" << m_strName << "-- eat" << endl;}
// 纯虚函数
virtual void move() = 0;
public:
// 数据成员
string m_strName;
};
/**
* 定义狗类：Dog
* 公有继承动物类
* 虚成员函数：eat()、move()
*/
class Dog : public Animal
{
public:
// 默认构造函数
Dog(){}
// 含参构造函数
Dog(string name){m_strName = name; cout << "Dog" << endl;}
// 虚析构函数
virtual ~Dog(){cout << "~Dog" << endl;}
// 虚成员函数eat()
virtual void eat(){cout << "Dog--" << m_strName << " -- eat" << endl;}
// 虚成员函数move()
virtual void move(){cout << "Dog--" << m_strName << " -- move" << endl;}
public:
// 数据成员
string m_strName;
};
int main(void)
{
// 通过动物类实例化狗类
Animal *dog = new Dog("狗类");
// 调用成员函数
dog->eat();
dog->move();
// 释放内存
delete dog;
dog = NULL;
return 0;
}
练习题3-8.【抽象类（接口类）】
定义一个能够射击（CanShut）类，要求含有纯虚函数aim和reload
定义一个枪（Gun）类，继承CanShut类，并实现函数aim和reload。
定义函数Hunting（CanShut *s）,调用s指向对象的函数。
在函数中传入Gun的对象，查看结果
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义射击类：CanShut
* 定义纯虚函数：aim、reload
*/
class CanShut
{
public:
virtual void aim() = 0;
virtual void reload() = 0;
};
/**
* 定义枪类：Gun
* 公有继承射击类
* 实现成员函数：aim、reload
*/
class Gun : public CanShut
{
public:
Gun(){}
virtual void aim()
{
cout << "Gun -- aim" << endl;
}
virtual void reload()
{
cout << "Gun -- reload" << endl;
}
};
/**
* 定义含参函数射击：hunting
* 调用参数的aim与reload函数
*/
void hunting(CanShut *s)
{
s->aim();
s->reload();
}
int main(void)
{
// 实例化枪对象
Gun *gun = new Gun();
// 调用含参函数hunting,将对象枪传入函数中
hunting(gun);
// 释放内存
delete gun;
gun = NULL;
return 0;
}
练习题3-8.【RTTI：Run-Time Type Identification运行时类型识别】
定义一个能够移动（Movable）类，要求含有纯虚函数move
定义一个公交车（Bus）类，继承Movable类，并实现函数move，定义函数carry
定义一个坦克（Tank）类，继承Movable类，并实现函数move，定义函数shot。
定义函数doSomething（Movable *obj）,根据s指向对象的类型调用相应的函数。
实例化公交车类和坦克类，将对象传入到doSomething函数中，调用相应函数
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
/**
* 定义移动类：Movable
* 纯虚函数：move
*/
class Movable
{
public:
virtual void move() = 0;
};
/**
* 定义公交车类：Bus
* 公有继承移动类
* 特有方法carry
*/
class Bus : public Movable
{
public:
virtual void move()
{
cout << "Bus -- move" << endl;
}
void carry()
{
cout << "Bus -- carry" << endl;
}
};
/**
* 定义坦克类：Tank
* 公有继承移动类
* 特有方法fire
*/
class Tank : public Movable
{
public:
virtual void move()
{
cout << "Tank -- move" << endl;
}
void fire()
{
cout << "Tank -- fire" << endl;
}
};
/**
* 定义函数doSomething含参数
* 使用dynamic_cast转换类型
*/
void doSomething(Movable *obj)
{
obj->move();
if(typeid(*obj) == typeid(Bus))
{
Bus *bus = dynamic_cast<Bus *>(obj);
bus->carry();
}
if(typeid(*obj) == typeid(Tank))
{
Tank *tank = dynamic_cast<Tank *>(obj);
tank->fire();
}
}
int main(void)
{
Bus b;
Tank t;
doSomething(&b);
doSomething(&t);
return 0;
}
练习题5-4.【异常处理】
函数division的两个参数为dividend（被除数）和divisor（除数）
要求用户输入除数和被除数，并作为参数传递给division函数
如果除数为0，则抛出异常，并被捕获，将异常的内容显示到屏幕上
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
/**
* 定义函数division
* 参数整型dividend、整型divisor
*/
int division(int dividend, int divisor)
{
if(0 == divisor)
{
// 抛出异常，字符串“除数不能为0”
throw string("除数不能为0");
}
else
{
return dividend / divisor;
}
}
int main(void)
{
int d1 = 0;
int d2 = 0;
int r = 0;
cin >> d1;
cin >> d2;
// 使用try...catch...捕获异常
try{
division(d1, d2);
}catch(string &e){
cout << e << endl;
}
return 0;
}
网友评论