C++面向对象程序设计（Visual C++2010版）课本例题源程序（上）

muse journal

已于 2023-12-11 16:16:16 修改

阅读量1.8k

点赞数 27

文章标签： c++ 学习 visual studio 编辑器笔记

于 2023-12-11 12:21:31 首次发布

本文链接：https://blog.csdn.net/muse3159546973/article/details/134918080

版权

前言

直至现在仍然有部分学校计算机专业的学生在学习C++面向对象程序设计时使用的是下面要说的比较古老的教材。下面有例题的源程序，希望对大家学习有帮助。

下半部分：C++面向对象程序设计（Visual C++2010版）课本例题源程序（下）-CSDN博客

编译器安装

注意：下述所有程序均在Microsoft Visual Studio 2010 旗舰版环境下运行

百度网盘链接：链接：https://pan.baidu.com/s/10KigPfJfmQmyFUCLww6KGw

提取码：4667

书籍介绍

目录 6
第1章　绪论 11
第2章　C++语言对C语言的扩充 26
第3章　类和对象 53
第4章　友元 112
习题 128
第5章　继承与派生 129
第6章　多态性和虚函数 170
第7章　C++语言的输入输出流库 215
第8章　异常处理 243
第9章　Windows编程基础和MFC编程基础 254
第10章　对话框和控件 297
第11章　菜单和文档/视图结构 347
第12章　图形设备接口 361
正文结束 373
附录A　程序的调试与运行 374
附录B　标准字符ASCII表 407
附录C　实验 409
附录D　模拟考试题一 415
附录E　模拟考试题二 426
附录F　参考课时安排 435
参考文献

例题源程序

第一章

ch1_1.cpp

// MyStack.cpp   类的实现文件
#include "MyStack.h"
#include <iostream>
using namespace std;

MyStack::MyStack(void)
{
	top = NULL; 
}

MyStack::~MyStack(void)
{
}

bool MyStack::push(int i)     // 压栈成员函数push的定义
{ 
	Node *p=new Node;
	if (p == NULL)
	{
		cout << "Stack is overflow.\n";
		return false;
	}
	else
	{
		p->content = i;
		p->next = top;
		top = p;
		return true;
	}
}

bool MyStack::pop(int& i)     // 弹栈成员函数pop的定义
{
	if (top == NULL) 
	{ 
		cout << "\n  Stack is empty.\n";
		return false;
	}
	else 
	{
		Node *p=top;
		top = top->next;
		i = p->content;
		delete p;
		return true;
	}
}

void MyStack::showElements(void)	// 显示堆栈中所有元素成员函数showElements的定义
{
	Node *p=top;
	while (p)
	{ 
		cout<<p->content<<"  ";
		p=p->next;
	}
	cout<<endl;
}

ch1_2.cpp

// MyStack.h  类的定义文件
#pragma once		// 避免同一个文件被包含多次
class MyStack		// 定义堆栈类MyStack
{
public:
	MyStack(void);		// 构造函数
	~MyStack(void);		// 析构函数
	bool push(int i);	// 压栈成员函数
	bool pop(int& i);	// 弹栈成员函数
	void showElements(void);// 显示堆栈中的所有元素
private:
	struct Node
	{
		int content;
		Node *next;
	} *top;				// 栈顶指针top
};

ch1_3.cpp

// TestMyStack.cpp  类的使用文件
#include "MyStack.h"
#include<iostream>
using namespace std;

int main()
{
	MyStack st1,st2;			// 定义MyStack类对象st1和st2
	int x,i;
	for(i=1;i<=5;i++)		// 将1到5五个数字分别压入堆栈st1和st2
	{
		st1.push(i);			// 压栈成员函数的调用
		st2.push(i);			// 压栈成员函数的调用
	}

	cout<<"堆栈st1的元素为：";
	st1.showElements();
	cout<<"堆栈st2的元素为：";
	st2.showElements();

	cout<<"\n-----对堆栈st1进行操作-----"<<endl;
	cout<<"  首先弹出3个元素，弹出的3个元素分别为：";
	
	for(i=1;i<=3;i++)			// 弹出3个元素，并输出显示
	{
		st1.pop(x);				// 弹栈成员函数的调用
		cout<<x<<"  ";

	}
	cout<<"\n  将20压入堆栈，堆栈st1的元素为：";
	st1.push(20);
	st1.showElements();

	cout<<"\n-----对堆栈st2进行操作-----"<<endl;
	cout<<"  弹出堆栈中的所有元素，弹出的元素分别为：";
	while(st2.pop(x))
		cout<<x<<"  ";
	st2.showElements();

	return 0;
}

第二章

ch2_1.cpp

//ch2_1.cpp
#include<iostream>	// 使用名空间std，则必须去掉.h扩展名
using namespace std; 
 
int main()
{
	char  name[10];
	int  age;
	cout<<"Please  input  your  name:";
	cin>>name;
	cout<<"How  old  are  you:";
	cin>>age;
	cout<<"Your name  is  "<<name<<endl;
	cout<<"Your age  is  "<<age<<endl;

	return 0;
}

ch2_2.cpp

#include<iostream>
using namespace std;

int main()
{  
	struct Student
	{
		int no;
		float math;
	};
	int n;
	cout<<"请输入学生学号：";
	cin>>n;
	Student stu1; 
	// C++中变量的定义语句可以出现在程序的任意位置
	// 可以直接使用结构体名定义变量，而无需加struct关键字
	stu1.no=n;
	cout<<"请输入学生的数学成绩：";
	cin>>stu1.math;
	cout<<"\n学生学号："<<stu1.no<<"\t"
		<<"数学成绩："<<stu1.math<<endl;

	return 0;
}

ch2_3.cpp

#include <iostream>
using namespace std;

int main()
{
	int *p;
	p = new int;   // 分配内存空间
	*p = 5;
	cout<<*p<<endl;
	
	delete p;   // 释放内存空间
	return 0;
}

ch2_4.cpp

#include <iostream>
using namespace std;

int main()
{
	int  i,n,*p;			// n表示数组元素的个数
	cout<< "请输入数组元素的个数 : ";
	cin>>n;

	if((p=new int[n])==0)		// 动态内存分配
	{
		cout<< "内存分配失败，退出！"<<endl;
		exit(1);
	}

	for( int i=0;i<n;i++)		// 为数组元素赋值
		p[i]= i *2;

	cout<<"数组中各元素分别为："<<endl;
	for( i=0;i<n;i++)
		cout<<p[i]<< "  ";
	cout<<endl;

	delete []p;					// 释放内存空间

	return 0;
}

ch2_5.cpp

#include <iostream>
using namespace std;

int main()
{
	int num=50;
	int &ref=num;
	ref+=10;
	cout<<"num="<<num<<endl;
	cout<< "ref="<<ref<<endl;
	num+=40;
	cout<< "num="<<num<<endl;
	cout<<"ref="<<ref<<endl;

	return 0;
}

ch2_6.cpp

#include <iostream>
using namespace std;

int main()
{
	int num;
	int & ref=num;
	num=5;
	cout<<"num="<<num<<endl;
	cout<<"ref="<<ref<<endl;
	cout<<"&num="<<&num<<endl;
	cout<< "&ref="<<&ref<<endl;

	return 0;
}

ch2_7.cpp

#include <iostream>   
using namespace std;

void swap(int &x,int &y);

int main()
{
	int x=10, y=20;
	cout <<"交换前： x = " <<x <<"   y = " <<y <<endl;
	swap(x,y);
	cout<<"交换后： x = "<<x<<"   y = "<<y<<endl;

	return 0;
}

void swap(int &rx,int &ry)		// 引用作为形参
{
	int temp=rx; 
	rx=ry; 
	ry=temp;

	return;
}

ch2_8.cpp

#include <iostream>   
using namespace std;

int array[6][4]={	{60,80,90,75},
					{75,85,65,77},
					{80,88,90,98},
					{89,100,78,81},
					{62,68,69,75},
					{85,85,77,91}
				  };
int& level(int grade[], int size, int& tA, int& tB);

int main()
{
	int typeA=0,typeB=0;
	int student=6;
	int gradesize=4;
	for(int i=0; i<student; i++)		// 对所有的学生数据进行处理
		level(array[i], gradesize, typeA, typeB)++;		// 函数调用作为左值
	cout <<"number of type A is " <<typeA <<endl;
	cout <<"number of type B is " <<typeB <<endl;

	return 0;
}

int& level(int grade[], int size,int& tA, int& tB)
{
	int sum=0;
	for(int i=0; i<size; i++)		// 成绩总分
		sum+=grade[i];
	sum/=size;						// 计算平均分
	if(sum>=80)
		return tA;					// A类学生
	else
		return tB;					// B类学生
}

ch2_9.cpp

#include <iostream>   
using namespace std;

float& fn2(float r)
{
	float temp;
	temp=r*r*3.14f;
	return temp;          // 返回了局部变量
}

int main()
{
	fn2(5.0f)=12.4f;
	// 返回的是局部作用域内的变量，函数调用作为左值使用。此种情况应尽量避免。
	return 0;
}

ch2_10.cpp

#include <iostream>
#include <string>  // 使用字符串string类型的程序应包含头文件<string>
using namespace std;

int main()
{
	string s,t;
	cout<<"请输入一个字符串:"<<endl;
	cin>>s;    // 由键盘输入一行文本，并把它赋给sring类型的变量s，注意：
	// 使用此方式输入的字符串中不能包含空白字符，具体请参见7.1.2小节
	t="I like programming!";
	cout<<"字符串的输出:"<<endl
		<<s<<endl<<t<<endl;
	cout<<s.append(" OK!")<<endl; // append为string类的成员函数

	return 0;
}

ch2_11.cpp

#include <iostream>
using namespace std;

inline double circumference(double radius);
// 内联函数的声明，如果此处省略inline关键字，即使在函数定义时加上inline关键字，
// 编译程序也不认为那是内联函数，对待该函数如普通函数那样，
// 产生该函数的调用代码并进行连接。
int main()
{
	double r=3.0,s;
	s=circumference(r);
	cout<<"the circumference is "<<s<<endl;
	return 0;
}

inline double circumference(double radius)
// 内联函数的定义，此处也可以省略inline关键字
{
	return 2*3.1415926*radius;
}

ch2_12.cpp

#include <iostream>
using namespace std;

int add(int x,int y)
{
	int sum;
	sum=x+y;
	return sum;
}

int add(int x,int y,int z)
{
	int sum;
	sum=x+y+z;
	return sum;
}

int main( )
{
	int a,b;
	a=add(5,10);
	b=add(5,10,20);
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;

	return 0;
}

ch2_13.cpp

#include<iostream>
using namespace std;

template<class T>	// 定义函数模板
T min(T a[ ],int n)
{
	int i;
	T minValue=a[0];
	for(i=1;i<n;i++)
		if(minValue >a[i])
			minValue=a[i];
	return minValue;
}

int main()
{
	int a[ ]={1,3,0,2,7,6,4,5,2};
	double b[ ]={1.2,-3.4,6.8,9,8};
	cout<<"a数组的最小值为："<<min(a,9)<<endl;
	cout<<"b数组的最小值为："<<min(b,4)<<endl;

	return 0;
}

ch2_14.cpp

#include<iostream>
using namespace std;
#define PI 3.1415926535

template<class T>
double Circle_Square(T x)
{
	return x*x*PI;
}

double Circle_Square(long x)
{
	return x*x*PI;
}

int main()
{
	int r1=1;
	double r2=2.0;
	long r3=3;
	cout<<"The first circle square is  "<<Circle_Square(r1)<<endl
		<<"The second circle square is "<<Circle_Square(r2)<<endl
		<<"The third circle square is  "<<Circle_Square(r3)<<endl;

	return 0;
}

第三章

ch3_1.cpp

// tdate.h  这个头文件只存放有关Tdate类的定义说明
#ifndef Tdate_H				// 用来避免重复定义
#define Tdate_H				// 不是类的一部分
class Tdate
{
public:
	void set(int,int,int);	// 成员函数原型
	int isLeapYear();
	void print();
private:
	int month;
	int day;
	int year;
};							//  Tdate类定义的结束
#endif						//  Tdate_H

// tdate.cpp    类Tdate的实现部分
#include<iostream>   /* 因为tdate.cpp文件要访问运算符<< 和ostream类对象cout，而这二者都是定义在iostream类中的，所以包含iostream头文件*/

#include"tdate.h"// 包含用户自定义的头文件，该文件中提供了Tdate类的定义
using namespace std;

void Tdate::set(int m,int d,int y)
{
	month = m; day = d; year = y;
}

int Tdate:: isLeapYear()
{
	return ((year % 4 == 0 && year % 100 != 0)||(year%400==0));
}

void Tdate::print()
{
	cout << month << "/" << day << "/" << year << endl;
}

ch3_2.cpp

// ch3_2.cpp
#include<iostream>
#include"tdate.h"
using namespace std;

void someFunc(Tdate& refs)
{
	refs.print();				// 通过对象的引用调用成员函数
	if(refs.isLeapYear())		// 通过对象的引用调用成员函数
		cout << "error\n";
	else
		cout << "right\n";
} 

int main()						// 类的应用部分
{
	Tdate s,*pTdate = &s;		// pTdate为指向Tdate类对象的指针
	s.set(2,15,1998);			// 通过对象调用成员函数
	pTdate -> print();			// 通过指向对象的指针调用成员函数
	if((*pTdate).isLeapYear())	// 通过指向对象的指针调用成员函数
		cout << "error\n";
	else
		cout << "right\n";
	someFunc(s);				// 对象的地址传给引用

	return 0;
}

ch3_3.cpp

// Cstack.h
#pragma once

const int SIZE = 10;	// 存储的最多字符数

class Cstack
{
public:
	Cstack(void);
	~Cstack(void);
	void init();
	char  push (char ch);
	char  pop();
private:
	char stk[SIZE];
	int  position;
};

// Cstack.cpp
#include "Cstack.h"
#include <iostream>
using namespace std;

Cstack::Cstack(void)
{
}

Cstack::~Cstack(void)
{
}

void Cstack::init()
{
	position = 0;
}

char Cstack::push(char ch)
{
	if(position == SIZE)
	{
		cout<<"\n栈已满 \n";
		return 0;
	}
	stk[position++] = ch;
	return  ch;
}

char Cstack::pop()
{
	if (position == 0)
	{
		cout<<"\n栈已空"<<endl;
		return 0;
	}
	return stk[--position];
}

// ch3_3.cpp
#include<iostream>
#include "Cstack.h"
using namespace std;

int main()
{
	Cstack s;
	s.init();
	char ch;
	cout<< "请输入字符："<<endl;
	cin>>ch;
	while(ch != '#'&& s.push(ch))
		cin>>ch;
	cout<< "\n现在输出栈内数据\n";
	while(ch = s.pop())
		cout <<ch<<" ";

	return 0;
}

ch3_4.cpp

// Tdate.h
#include <iostream>
using namespace std;

class Tdate
{
public:
	void set(int m=5,int d=16,int y=1990)		// 置日期值
	{
		month=m; day=d; year=y;
	}
	void print()		// 输出日期值
	{
		cout<<month<<"/"<<day<<"/"<<year<<endl;
	}
private:
	int month;
	int day;
	int year;
};

// ch3_4.cpp
#include "Tdate.h"

int main()
{
	Tdate a,b,c,d;
	a.set(4,12,1996);
	b.set(3);
	c.set(8,10);
	d.set();
	a.print();
	b.print();
	c.print();
	d.print();

	return 0;
}

ch3_5.cpp

//ch3_5.cpp
#include<iostream>
using namespace std;

class Cube
{
public:
	int volume(int  ht,int wd)
	{
		return ht*wd;
	}
	int volume(int ht,int wd,int dp)
	{
		height=ht;
		width=wd;
		depth=dp;
		return height*width*depth;
	}
private:
	int height,width,depth;
};

int main()
{
	Cube cube1;
	cout << cube1.volume(10,20) << endl;// 调用带2个参数的成员函数
	cout << cube1.volume(10,20,30) << endl;
	// 调用带3个参数的成员函数

	return 0;
}

ch3_6.cpp

// MyQueue.h
#pragma once
class MyQueue
{
public:
	MyQueue(void);
	~MyQueue(void);
	void qput(int i );
	int qget( );
private:
	int q[100];
	int sloc,rloc;
};

// MyQueue.cpp
#include "MyQueue.h"
#include <iostream>
using namespace std;

MyQueue::MyQueue(void)
{
	sloc=rloc=0;
	cout<< "queue initialized\n";
}

MyQueue::~MyQueue(void)
{
}

void MyQueue::qput(int i)
{
	if(sloc == 100)
	{
		cout<< "queue is full\n";
		return;
	}
	sloc++;
	q[sloc]=i ;
}

int MyQueue::qget( )
{
	if(rloc==sloc)
	{
		cout<< "queue is empty\n";
		return 0;
	}
	rloc++;
	return q[rloc];
}

// ch3_6.cpp
#include "MyQueue.h"
#include <iostream>
using namespace std;

int main()
{
	MyQueue a,b;
	a.qput(10);
	b.qput(20);
	a.qput(20);
	b.qput(19);
	cout<<a.qget( )<< "   ";
	cout<<a.qget( )<< "\n";
	cout<<b.qget( )<< "   ";
	cout<<b.qget( )<< "\n";
	return 0;
}

ch3_7.cpp

//TestOverloadConstructor.h
#pragma once
class TestOverloadConstructor
{public:
      TestOverloadConstructor(void);
      ~TestOverloadConstructor(void);
      TestOverloadConstructor(int n,float f);
private:
    int num;
    float f1;
};

//TestOverloadConstructor.cpp
#include"TestOverloadConstructor.h"
#include<iostream>
using namespace std;
TestOverloadConstructor::TestOverloadConstructor(void)
{    num=0;
     f1=0.0;
     cout<<"Initializing default"<<num<<","<<f1<<endl;
     cout<<"----------------------------"<<endl;
}
TestOverloadConstructor::TestOverloadConstructor(int n,float f)
{num=n;
f1=f;
     cout<<"Initializing "<<num<<","<<f1<<endl;
     cout<<"----------------------------"<<endl;
}
TestOverloadConstructor::~TestOverloadConstructor(void)
{
}

//ch3_7.cpp
#include<"TestOverloadConstructor.h">
int main()
{TestOverloadConstructor x;
 TestOverloadConstructor y(10,21.5f);
TestOverloadConstructor *px=new TestOverloadConstructor;
//调用无用的构造参数
TestOverloadConstructor *py=new TestOverloadConstructor(100,36.6f);
//调用带两个参数的构造函数
return 0；
}

ch3_8.cpp

// Tdate.h
#pragma once
class Tdate
{
public:
	Tdate(int m=5,int d=16,int y=1990);	
	~Tdate(void);
private:
	int month;
	int day;
	int year;
};

// Tdate.cpp
#include "Tdate.h"
#include <iostream>
using namespace std;

Tdate::Tdate(int m,int d,int y)
{
	month=m;  day=d;  year=y;
	cout <<month <<"/" <<day <<"/" <<year <<endl;
}



Tdate::~Tdate(void)
{
}

// ch3_8.cpp
#include "Tdate.h"

int main()
{
	Tdate aday;
	Tdate bday(2);
	Tdate cday(3,12);
	Tdate dday(1,2,1998);
	return 0;
}

ch3_9.cpp

// ch3_9.cpp
#include<iostream>
#include <string>
using namespace std;

class Student
{
public:
	Student(char* pName)
	{
		cout<<"call one parameter constructor"<<endl;
		strncpy_s(name,pName,sizeof(name));
		name[sizeof(name)-1]= '\0';
		cout<<"the name is "<<name<<endl;
	}
	Student(){cout<<"call no parameter constructor"<<endl;}  
	void display()
	{
		cout<<"the name of the student is "<<name<<endl;
	}
protected:
	char name[20];
};

int main()
{
	static Student noName1;  
	Student noName2;
	Student ss("Jenny");  
	noName1.display();
	noName2.display();
	return 0;
}

ch3_10.cpp

//Test.h
#pragma once
class Test
{
public:
	Test(void);
	~Test(void);
	Test(int n, float f);        // 参数化的构造函数
	int getInt();
	float getFloat();
private:
	int num;
	float f1;
};

//Test.cpp
#include "Test.h"
#include <iostream>
using namespace std;

Test::Test(void)
{ 
	num = 0;
	f1 = 0.0;
	cout<<"Initializing default"<<endl;
}

Test::Test(int n, float f)
{
	num = n;
	f1 = f;
	cout<<"Initializing "<<num<<", "<<f1<<endl;
}

int Test::getInt()
{return num;}

float Test::getFloat()
{return f1;}

Test::~Test(void)
{
}

// ch3_10.cpp
#include "Test.h"
#include<iostream>
using namespace std;

int main()
{
	cout<<"the main function:"<<endl;
	Test array[5];
	cout<<"the second element of array is "<<array[1].getInt()
		<<"   "<<array[1].getFloat()<<endl;

	return 0;
}

ch3_11.cpp

// ch3_11.cpp
#include<iostream>
using namespace std;

class Test
{
private:
	int num;
	float f1;
public:
	Test(int n);
	Test(int n, float f);   
};

Test::Test(int n)
{
	num = n;
	cout<<"Initializing "<<num<<endl;
}
Test::Test(int n, float f)
{
	num = n;
	f1 = f;
	cout<<"Initializing "<<num<<", "<<f1<<endl;
}

int main()
{
	Test array1[3] = {1,2,3};
	cout<<"-----------------"<<endl;
	Test array2[] = {Test(2,3.5),Test(4)};
	cout<<"-----------------"<<endl;
	Test array3[] = {Test(5.5,6.5),Test(7,8.5)};
	// array3有2个元素
	cout<<"-----------------"<<endl;
	Test array4[] = {Test(5.5, 6.5), 7.5, 8.5};
	// array4有3个元素

	return 0;
}

ch3_12.cpp

// ch3_12.cpp
//#include<cstring>
#include<iostream>
using namespace std;

class Person
{
public:
	Person(char *na)	// 构造函数
	{
		cout<<"call constructor"<<endl;
		name=new char[strlen(na)+1];	// 使用new进行动态内存分配
		if(name!=0)
		{strcpy_s(name,strlen(na)+1,na);}
	}

	Person(Person&p)	// 深拷贝构造函数
	{
		cout<<"call copy constructor"<<endl;
		name=new char[strlen(p.name)+1];	// 复制资源
		if(name!=0)
			strcpy_s(name,strlen(p.name)+1,p.name);			// 复制对象空间
	}

	void printName()
	{
		cout<<name<<endl;
	}

	~Person()	// 析构函数的定义，参见3.3.2小节
	{
		delete name;
	} 		
private:
	char *name;
};			// 类定义的结束

int main()
{
	Person wang("wang");
	Person li(wang);
	wang.printName();
	li.printName();

	return 0;
}

ch3_13.cpp

// ch3_13.cpp
class  SillyClass
{
public:
	SillyClass(int&i):TEN(10),refI(i)
	{ }
protected:
	const int TEN;	// 常量数据成员
	int&refI;		// 引用数据成员
};

int main()
{
	int  i ;
	SillyClass sc(i);

	return 0;
}

ch3_14.cpp

// ch3_14.cpp
#include<iostream>
using namespace std;

class RMB
{
public:
	RMB(double value = 0.0)		// 转换构造函数
	{
		yuan = value;
		jf = ( value - yuan ) * 100 + 0.5;
	}
	operator double()			// 类类型转换函数
	{
		return yuan + jf / 100.0; 
	}		
	void display()
	{ 
		cout << (yuan + jf / 100.0) << endl;
	}
private:
	unsigned int yuan;
	unsigned int jf;
};

int main()
{
	RMB d1(2.0), d2(1.5), d3;
	d3 = RMB((double)d1 + (double)d2);	// 显式转换
	d3.display();
	d3 = d1 + d2;     
	/* 隐式转换，系统首先会调用类类型转换函数把对象d1和d2隐式转换为double数据类型， 然后进行相加，加完的结果再调用构造函数隐式转换为RMB类类型，赋给d3。*/
	d3.display();

	return 0;
}

ch3_15.cpp

// ch3_15.cpp
#include <iostream>
using namespace std;

class Student{
public:
	Student(char* pName="no name",int ssId=0)
	{
		strncpy_s(name,pName,40);
		name[39]= '\0';
		id = ssId;
		cout <<"Constructing new student " <<pName <<endl;
	}
	Student(Student& s)              // 拷贝构造函数
	{
		cout <<"Constructing copy of "<<s.name <<endl;
		strcpy_s(name, "copy of ");
		strcat_s(name,s.name);
		id=s.id;
	}
	~Student()
	{
		cout <<"Destructing " <<name <<"\t"<<id<<endl;
	}
private:
	char name[40];
	int id;
};

void fn(Student s)
{
	cout <<"In function fn()\n";     // fn函数调用结束时，析构对象s
	Student zhang("zhang",3);
	static Student zhao("zhao",4);
}

int main()
{
	Student randy("Randy",1);     // 调用构造函数，创建对象randy
	Student wang("wang",2);       // 调用构造函数，创建对象wang
	cout <<"---Calling fn()---\n";
	fn(randy);                       // 调用fn函数，参数传递时调用拷贝构造函数
	cout <<"---Returned from fn()---\n";
	// 主函数调用结束时，先析构对象wang，再析构对象randy

	return 0;
}

ch3_16.cpp

//ch3_16.cpp
#include <iostream>
using namespace std;

class StudentID{
public:
	StudentID(int id=0)	// 带缺省参数的构造函数
	{
		value=id;

		cout <<"Assigning student id " <<value <<endl;
	}
	~StudentID()
	{
		cout <<"Destructing id " <<value <<endl;
	}
private:
	int value;
};

class Student{
public:
	Student(char* pName="no name",int ssID=0):id(ssID)
	{
		cout <<"Constructing student " <<pName <<endl;
		strncpy_s(name,pName,sizeof(name));
		name[sizeof(name)-1]='\n';
	}
	~Student()
	{
		cout<<"Deconstructing student  "<<name<<endl;
	}
protected:
	char name[20];
	StudentID id;	// 对象成员
};

int main()
{
	Student s("wang",9901);
	Student t("li");
	cout<<"----------------------"<<endl;

	return 0;
}

ch3_17.cpp

//ch3_17.cpp
#include<iostream>
using namespace std;

class Student			// 学生类的定义
{
public:
	Student()
	{
		cout<<"constructing student."<<endl;
		semesHours=100;
		gpa=3.5;
	}
	~Student()
	{
		cout<<"destructing student."<<endl;
	}
protected:
	int semesHours;
	float gpa;
};

class Teacher			// 教师类的定义
{
public:
	Teacher()
	{
		cout<<"constructing teacher.\n";
	}
	~Teacher()
	{
		cout<<"destructing teacher.\n";
	}
};

class Tutorpair			// 帮教类的定义
{
public:
	Tutorpair()
	{
		cout<<"constructing tutorpair."<<endl;
		nomeeting=0;
	}
	~Tutorpair()
	{
		cout<<"destructing tutorpair."<<endl;
	}
protected:
	Student student;
	Teacher teacher;
	int nomeeting;			// 会晤时间
};

int main()
{
	Tutorpair tp;
	cout<<"------back to main function.------"<<endl;

	return 0;
}

ch3_18.cpp

// ch3_18.cpp
#include<iostream>
using namespace std;

class  A
{
public:
	A()
	{
		numbers++;
	}
	int  getNumbers()
	{
		return  numbers;
	}
	static  int  numbers;      // 定义静态数据成员
};
int  A::numbers=0;	// 静态数据成员的初始化

int  main()
{
	cout<<A::numbers<<endl;
	A  a1,a2,a3;
	cout<<A::numbers<<'\t'
		<<a1.getNumbers()<<'\t'
		<<a2.getNumbers()<<'\t'
		<<a3.getNumbers()<<endl;
	// 显示均为3（因为创建三个对象，三次使得静态数据成员自增1）
	return 0;
}

ch3_19.cpp

//ch3_19.cpp
#include <iostream>
using namespace std;

class Student{
public:
	Student(char* pName ="no name")
	{
		cout <<"create one student\n";
		strncpy_s(name,pName,40);
		name[39]='\0';
		numbersOfStudent++;		// 静态成员：每创建一个对象，学生人数增1
		cout <<"现有 "<<numbersOfStudent <<" 个学生"<<endl;
	}
	~Student()
	{
		cout <<"destruct one student\n";
		numbersOfStudent--;		// 每析构一个对象，学生人数减1
		cout <<"现有 "<<numbersOfStudent <<" 个学生"<<endl;
	}
	static int getNumbers()		// 静态成员函数
	{
		return numbersOfStudent;
	}
private:
	static int numbersOfStudent;	// 若写成numbersOfStudent=0;则非法
	char name[40];
};
int Student::numbersOfStudent =0;	// 静态数据成员在类外分配空间和初始化

void fn()
{
	cout<<"-------In fn function-------"<<endl;
	Student s1;
	Student s2;
}

int main()
{
	//Student wang;
	fn();
	cout<<"-------Back to main function-------"<<endl;
	// 调用静态成员函数用类名引导
	cout <<"现有 "<<Student::getNumbers()<<" 个学生"<<endl;

	return 0;
}

ch3_20.cpp

// ch3_20.cpp
#include <iostream>
#include "Student.h"
using namespace std;

Student* fn()
{
	cout<<"------In fn()------"<<endl;
	Student* p =new Student("Jenny");
	Student s3("Jone");
	return p;
}

int main()
{
	Student s1("Jamsa");
	Student* ps =fn();
	cout<<"------Back to main()------"<<endl;
	Student s2("Tracey");
	delete ps;

	return 0;
}

ch3_21.cpp

// ch3_21.cpp
#include<iostream>
using namespace std;
 
class Student
{
public:
	Student(int id1,char name1[],int score1)
	{
		id = id1;
		score = score1;
		strcpy_s(name, name1);
		sum += score1;		// 求学生成绩总和
		number++;			// 学生人数自增
	}
	static double average()
	{
		return sum / number;// 求所有学生的平均分
	}
	void display()
	{
		cout<<id<<'\t'<<name<<'\t'<<score<<endl;
	}
private:
	int id;
	char name[10];
	int score;
	static double sum;
	static int number;
};
 
double Student::sum = 0.0;
int Student::number = 0;
 
int main()
{
	Student s1(1,"Li",89),s2(2,"Chen",78),s3(3,"Zheng",95);
	cout<<"学号   姓名   成绩"<<endl;
	s1.display();
	s2.display();
	s3.display();
	cout<<"所有学生的平均分 = "<<Student::average()<<endl;

	return 0;
}

ch3_22.cpp

// ch3_22.cpp
#include<iostream>
using namespace std;

class  A
{
public:
	int  i,*p;
	A(){i=10;p=&i;}
};

int  A::*p=&A::i;	// p是类外指针数据

int  main()
{
	A  aa,bb;        // 按缺省构造函数的安排，aa、bb中的i初值都是10
	(bb.*p)++;      // 括号不可缺，否则编译器将理解为非法操作
	--*aa.p;
	cout<<"AA:"<<aa.*p<<"  BB:"<<bb.*p<<"\n";
	cout<<"AA:"<<*aa.p<<"  BB:"<<*bb.p<<endl;

	return 0;
}

ch3_23.cpp

//ch3_23.cpp
#include<iostream>
using namespace std;

class  A
{
public:
	int set(int k)
	{
		i=++k;
		return i;
	}
private:
	int i;
};

int main()
{
	int  (A::*f)(int)=&A::set;
	A  aa;
	cout<<(aa.*f)(10)<<endl;       // 括号不能省略

	return 0;
}

ch3_24.cpp

// ch3_24.cpp
#include<iostream>
using namespace std;

class A
{
public:
	static void set(int k)
	{
		i=k;i++;
	}
private:
	static int i;
	friend class B;
};

class B
{
public:
	static void ds(int l)
	{
		int *p=&A::i;
		cout<<*p<<endl;
		*p=l;cout<<*p<<endl;
	}
};

int  A::i=0;
void  (*f1)(int)=&A::set;
void  (*f2)(int)=&B::ds;

int main()
{
	f1(10);
	f2(20);

	return 0;
}

ch3_25.cpp

// Set.h
#pragma once

const int maxCard = 16;		// 集合中元素个数的最大值，默认为int型
enum ErrCode {noErr, overflow};		// 错误代码
enum Bool {False, True};			// Bool类型定义

class Set							// 定义集合类
{
public:
	Set(void);
	~Set(void);
	void EmptySet( ){card = 0;}
	Bool Member(int);				// 判断一个数是否为集合中的元素
	ErrCode AddElem(int);			// 向集合中添加元素
	void RmvElem(int);				// 删除集合中的元素
	void Copy(Set *);		// 把当前集合拷贝到形参指针指向的集合中
	Bool Equal(Set *);				// 判断两个集合是否相等
	void Print( );
	void Intersect(Set *, Set *);	// 交集
	ErrCode Union(Set *, Set *);	// 并集
private:
	int elems[maxCard];			// 存储元素的数组
	int card;					// 集合中元素的个数
};

// Set.cpp
#include "Set.h"
#include <iostream>
using namespace std;

Set::Set(void)
{
}

Set::~Set(void)
{
}

Bool Set::Member(int elem)
{
	for(int i=0;i<card;++i)
		if(elems[i] == elem)
			return True;
	return False;
}

ErrCode Set::AddElem(int elem)
{
	if(Member(elem))
		return noErr;
	if(card < maxCard)
	{
		elems[card++] = elem;
		return noErr; 
	}
	return overflow;
}

void Set::RmvElem(int elem)
{
	for(int i = 0; i<card; ++i)
		if(elems[i] == elem)
		{
			for(;i<card-1;++i)
				elems[i] = elems[i+1];
			--card;
	        return;
		}
}

void Set::Copy(Set *set)
{
	for(int i = 0; i < card; ++i)
		set->elems[i] = elems[i];
	set->card = card;
}

Bool Set::Equal(Set *set)
{
	if(card != set->card)
		return False;
	for(int i = 0; i < card;++i) 
		// 判断当前集合的某元素是否是set所指集合中的元素
		if(!set->Member(elems[i])) 
			return False;
	return True;
}

void Set::Print( )
{
	cout<<"{";
	for(int i = 0; i < card; ++i)
		cout << elems[i]<< ";";
	cout<<"}\n";
}

void Set::Intersect(Set *set, Set *res)// 交集：*this∩*set->*res
{
	res->card = 0;
	for(int i = 0; i < card; ++i)
		for(int j = 0; j < set->card; ++j)
			if(elems[i] == set->elems[j]){
				res->elems[res->card++] = elems[i];
				break;
			}
}

ErrCode Set::Union(Set *set,Set *res) // 并集：*set∪*this->*res
{
	set->Copy(res);
	for(int i = 0; i < card; ++i)
		if(res->AddElem(elems[i]) == overflow)
			return overflow;
    return noErr;
}

// ch3_25.cpp
#include "Set.h"
#include <iostream>
using namespace std;

// 下面是测试用的程序代码
int main( )
{
	Set s1, s2, s3;
	s1.EmptySet( );
	s2.EmptySet( );
	s3.EmptySet( );
	s1.AddElem(10);
	s1.AddElem(20);
	s1.AddElem(30); 	
	s1.AddElem(40);
	s2.AddElem(30);
	s2.AddElem(50);
	s2.AddElem(10); 	 
	s2.AddElem(60);
	cout<<"s1="; 	s1.Print( );
	cout<<"s2=";	s2.Print( );
	s2.RmvElem(50);
	cout<<"s2-{50}=";	s2.Print( );
	if(s1.Member(20))
		cout<<"20 is in s1\n";
	s1.Intersect(&s2,&s3);
	cout<<"s1 intsec s2 =";	s3.Print( );
	s1.Union(&s2,&s3);
	cout<<"s1 union s2 =";	s3.Print( );
	if(!s1.Equal(&s2))
		cout<<"s1!=s2\n";

	return 0;
}

ch3_26.cpp

//Set.h
#pragma once

const int maxCard=16;			     // 集合中元素个数的缺省最大值
enum ErrCode {noErr, overflow};	 // 错误代码
enum Bool {False, True};		    // Bool类型定义
class Set
{
public:
	Set(int sz=maxCard);
	~Set( );
	Bool Member(int);				// 判断一个数是否为集合中的元素
	ErrCode AddElem(int);			// 向集合中添加元素
	void RmvElem(int);				// 删除集合中的元素
	void Copy(Set *);		// 把当前集合拷贝到形参指针指向的集合中
	Bool Equal(Set *);		// 判断两个集合是否相等
	void Print( );
	void Intersect(Set *, Set *);	// 交集
	ErrCode Union(Set *, Set *);	// 并集
private:
	int size;		// 元素的最大个数
	int *elems;		// 存储元素的数组
	int card;		// 集合中元素的个数 
};

// Set.cpp
#include "Set.h"
#include<iostream>
using namespace std;

Set::Set(int sz)
{
	card=0;
	size=sz;
	elems=new int[size];
}

Set::~Set(void)
{
	delete []elems;
}

Bool Set::Member(int elem)
{
	for(int i=0;i<card;++i)
		if(elems[i]==elem)
			return True;
	return False;
}

ErrCode Set::AddElem(int elem)
{
	if(Member(elem))
		return noErr;
	if(card<size)
	{
		elems[card++]=elem;
		return noErr;
	}
	return overflow;
}

void Set::RmvElem(int elem)
{
	for(int i=0;i<card;++i)
		if(elems[i]==elem)
		{
			for(;i<card-1;++i)
				elems[i]=elems[i+1];
			--card;
			return;
		}
}

void Set::Copy(Set *set)
{
	if(set->size<size)
	{
		delete [ ]set->elems;
		set->elems = new int[size];
		set->size = size;
	}
	for(int i=0;i<card;++i)
		set->elems[i]=elems[i];
	set->card=card;
}

Bool Set::Equal(Set *set)
{
	if(card!=set->card)
		return False;
	for(int i=0;i<card;++i)
		if(!set->Member(elems[i]))
			return False;
	return True;
}

void Set::Print( )
{
	cout<<"{";
	for(int i=0;i<card-1;++i)
		cout<<elems[i]<< ";";
	if(card>0)
		cout<<elems[card-1];
	cout<<"}\n";
}

void Set::Intersect(Set *set, Set *res)
{
	if(res->size<size)
	{
		delete [ ]res->elems;
		res->elems = new int[size];
		res->size = size;
	}
	res->card=0;
	for(int i=0;i<card;++i)
		for(int j=0;j<set->card;++j)
			if(elems[i]==set->elems[j])
			{
				res->elems[res->card++]=elems[i];
				break;
			}
}

ErrCode Set::Union(Set *set, Set *res)
{
	if(res->size<size+set->size)
	{
		delete []res->elems;
		res->elems = new int[size+set->size];
		res->size = size+set->size;
	}
	set->Copy(res);
	for(int i=0;i<card;++i)
		if(res->AddElem(elems[i])==overflow)
			return overflow;
	return noErr;
}

// ch3_26.cpp
#include"Set.h"
#include<iostream>
using namespace std;

int main( )
{
	Set s1, s2, s3;
	s1.AddElem(10);
	s1.AddElem(20);
	s1.AddElem(30); 	
	s1.AddElem(40);
	s2.AddElem(30);
	s2.AddElem(50);
	s2.AddElem(10);
	s2.AddElem(60);
	cout<<"s1="; 	s1.Print( );
	cout<<"s2=";	s2.Print( );
	s2.RmvElem(50);
	cout<<"s2-{50}=";	s2.Print( );
	if(s1.Member(20))
		cout<<"20 is in s1\n";
	s1.Intersect(&s2,&s3);
	cout<<"s1 intsec s2 =";	s3.Print( );
	s1.Union(&s2,&s3);
	cout<<"s1 union s2 =";		s3.Print( );
	if(!s1.Equal(&s2))
		cout<<"s1!=s2\n";
	return 0;
}

第四章

ch4_1.cpp

// ch4_1.cpp
#include<iostream>
#include<string>
using namespace std;

class  Student
{
public:
	Student(char*s1,char*s2)
	{
		strcpy_s(name,s1);
		strcpy_s(num,s2);
	}
	void display()
	{
		cout<<"Name:"<<name<<endl
			<<"Number:"<<num<<endl;
	}
private:
	char name[10],num[15];
};

class Score
{	
public:
	Score(unsigned int i1,unsigned  int i2,unsigned int  i3)
:mat(i1),phy(i2),eng(i3)
	{   }
	void  displayScore()
	{
		cout<<"Mathematics:"<<mat
			<<"\nPhyics:"<<phy
			<<"\nEnglish:"<<eng<<endl;
	}
private:
	unsigned int mat,phy,eng;
};

int main()
{
	Student  student1("Wang","20163030101");
	Score  score1(72,82,92);
	student1.display();
	score1.displayScore();

	return 0;
}

ch4_2.cpp

// ch4_2.cpp
#include<iostream>
#include<string>
using namespace std;

class  Student
{
public:
	Student(char  *s1,char  *s2)
	{strcpy_s(name,s1);strcpy_s(num,s2);}
private:
	char name[10],num[10];
	friend void	show(Student& st)          // 友元函数的声明和定义
	{
		cout<<"Name:"<<st.name<<endl<<"Number:"<<st.num<<endl;
	}
};
class  Score
{
public:
	Score(unsigned  int  i1,unsigned int  i2,unsigned  int i3)
		:mat(i1),phy(i2),eng(i3)
	{  }
private:
	unsigned  int  mat,phy,eng;
	friend  void  show_all(Student&,Score*);     // 友元函数的声明
};

void  show_all(Student&	st,Score*  sc)       // 友元函数的定义
{
	show(st);
	cout<<"Mathematics:"<<sc->mat
		<<"\nPhyics:"<<sc->phy
		<<"\nEnglish:"<<sc->eng<<endl;
}
int main()
{
	Student  wang("Wang","9901");
	Score  ss(72,82,92);
	show_all(wang,&ss);

	return 0;
}

ch4_3.cpp

// ch4_3.cpp
#define MAXLENGTH 32
#include<iostream>
using namespace std;

class RealSet;	
enum errcode
{  noerr,overflow };	// 定义枚举类型errcode

class IntSet			// 定义整数集合类IntSet
{
public:
	IntSet( )
	{ 
		card=0;
	}
	errcode addElem(int);	// 向集合中增加元素
	void print( );
	void setToReal(RealSet *set);
	// 将当前对象的整数集合转换成浮点数集合RealSet
private:
	int elem[MAXLENGTH];
	int card;
};

class RealSet                      // 定义一个浮点数集合类
{
public:
	RealSet( )
	{
		card=0;
	}
	errcode addElem(float);
	void print( );
private:
	float elem[MAXLENGTH];
	int card;	
};

errcode IntSet::addElem(int elem1)
{
	for(int i=0;i<card;i++)
		if(elem[i]==elem1)
			return noerr;
	if(card<MAXLENGTH)
	{
		elem[card++]=elem1;
		return noerr;
	}
	else return overflow;
}

void IntSet::print( )
{
	cout<< "{";
	for(int i=0;i<card-1;++i)
		cout<<elem[i]<<",";
	if(card>0)
		cout<<elem[card-1];
	cout<< "}\n";
}

void IntSet::setToReal(RealSet *set)
{
	for(int i=0;i<card;i++)
		set->addElem((float)elem[i]);
}

errcode RealSet::addElem(float elem1)
{
	for(int i=0;i<card;i++)
		if(elem[i]==elem1)
			return noerr;
	if(card<MAXLENGTH)
	{
		elem[card++]=elem1;
		return noerr;
	}
	else return overflow;
}

void RealSet::print( )
{
	cout<< "{";
	for(int i=0;i<card-1;++i)
		cout<<elem[i]<< ",";
	if(card>0)
		cout<<elem[card-1];
	cout<< "}\n";
}

int main( )
{
	IntSet set1;
	RealSet *set2;
	set2=new RealSet;
	set1.addElem(12);
	set1.addElem(278);
	set1.addElem(54);
	set1.addElem(459);
	set1.print( );
	set1.setToReal(set2);
	set2->print();
	delete set2;

	return 0;
}

// ch4_3_1.cpp
#define MAXLENGTH 32
#include<iostream>
using namespace std;

class RealSet;	
enum errcode
{  noerr,overflow };                // 定义一个枚举

class IntSet                        // 定义一个整数集合类
{
public:
	IntSet( )
	{ 
		card=0;
	}
	errcode addElem(int);            // 向集合中增加符点数元素
	void print( );
	friend void setToReal(IntSet *, RealSet *);
private:
	int elem[MAXLENGTH];
	int card;
};

class RealSet                      // 定义一个浮点数集合类
{
public:
	RealSet( )
	{
		card=0;
	}
	errcode addElem(float);
	void print( );
	friend void setToReal(IntSet *,RealSet *);
private:
	float elem[MAXLENGTH];
	int card;	
};

errcode IntSet::addElem(int elem1)
{
	for(int i=0;i<card;i++)
		if(elem[i]==elem1)
			return noerr;
	if(card<MAXLENGTH)
	{
		elem[card++]=elem1;
		return noerr;
    }
    else return overflow;
}

void IntSet::print( )
{
	cout<< "{";
	for(int i=0;i<card-1;++i)
		cout<<elem[i]<<",";
	if(card>0)
		cout<<elem[card-1];
	cout<< "}\n";
}

errcode RealSet::addElem(float elem1)
{
	for(int i=0;i<card;i++)
		if(elem[i]==elem1)
			return noerr;
	if(card<MAXLENGTH)
	{
		elem[card++]=elem1;
		return noerr;
	}
	else return overflow;
}

void RealSet::print( )
{
	cout<< "{";
	for(int i=0;i<card-1;++i)
		cout<<elem[i]<< ",";
	if(card>0)
		cout<<elem[card-1];
	cout<< "}\n";
}

void setToReal(IntSet *set1, RealSet *set2)
{
	set2->card= set1->card;
	for(int i =0; i< set1->card; i++)
		set2->elem[i]=(float)set1->elem[i];
}

int main( )
{
	IntSet *set1;
	RealSet *set2;
	set1=new IntSet;
	set2=new RealSet;
	set1->addElem(12);
	set1->addElem(278);
	set1->addElem(54);
	set1->addElem(459);
	set1->print( );
	setToReal(set1,set2);
	set2->print(); 
	delete set1;
	delete set2;

	return 0;
}

ch4_4.cpp

// ch4_4.cpp
#include<iostream>
using namespace std;

class  Student;		    // 声明引用的类名
class  Score
{
public:
	Score(unsigned int i1,unsigned int i2,unsigned int i3):mat(i1),phy(i2),eng(i3){}
	void  show()
	{
		cout<<"Mathematics:"<<mat
			<<"\nPhyics:"<<phy
			<<"\nEnglish:"<<eng<<endl;
	}
	void  show(Student&);
private:
	unsigned  int  mat,phy,eng;
};

class Student
{
public:
	Student(char *s1,char *s2)
	{
		strcpy_s(name,s1);
		strcpy_s(num,s2);
	}
	friend void Score::show(Student&);      // 声明友元成员
private:
	char name[10],num[10];
};

void  Score::show(Student&  st)
{
	cout<<"Name:"<<st.name<<"\n";
	show();
}

int main()
{
	Student  wang("Wang","9901");
	Score  ss(72,82,92);
	ss.show(wang);

	return 0;
}

ch4_5.cpp

// ch4_5.cpp
#include<iostream>
using namespace std;

class Student
{
public:
	Student(char *s1,char *s2)
	{
		strcpy_s(name,s1);
		strcpy_s(num,s2);
	}
	friend class Score;             // 声明Score类为Student类的友元类
private:
	char name[10],num[10];
};

class Score
{
public:
	Score(unsigned int i1,unsigned int i2,unsigned int i3)
:mat(i1),phy(i2),eng(i3)
	{  }
	void show()
	{	cout<<"Mathematics:"<<mat<<"\nPhyics:"<<phy<<"\nEnglish:"<<eng<<endl;
	}
	void show(Student&);
private:
	unsigned int mat,phy,eng;
};

void Score::show(Student& st)
{
	cout<<"Name:"<<st.name<<"\n";
	show();
}

int main()
{
	Student wang("Wang","9901");
	Score ss(72,82,92);
	ss.show(wang);

	return 0;
}

ch4_6.cpp

// ch4_6.cpp
#include<iostream>
using namespace std;

class  Stack;		// 超前声明Stack类，因为Node类中要将它声明为友员
class  Node			// 定义Node类
{
public:
	Node(int d,Node * n) 		// 构造函数
	{        
		data=d;
		prev=n;
	}
	friend class Stack;			// 声明友元类
private:
	int data; 					// 结点值
	Node * prev; 				// 指向上一结点的指针
};

class Stack						// 定义堆栈类
{  
public:
	Stack( )
	{
		top=0;
	}
	void push(int i ); 			// 压栈
	int pop( ); 				// 弹栈
private:
	Node * top; 				// 堆栈头
};

void Stack::push(int i)
{
	Node * n=new Node(i,top);
	top=n;
}

int Stack::pop( )
{
	Node * t=top;
	if(top)
	{
		top=top->prev;
		int c=t->data;
		delete t;
		return c;
	}
	return 0;
}

int main( )
{
	int data,i;
	Stack s;
	cout<<"请输入10个整数："<<endl;
	for(i=0;i<10;i++)
	{
		cin>>data;
		s.push(data);
	}
	for(i=0;i<10;i++)
		cout<<s.pop()<<"   ";
	cout<< "\n";

	return 0;
}

ch4_7.cpp

// ch4_7.cpp
#include<iostream>
using namespace std;

class Complex
{
public:
	Complex(double r = 0, double i = 0)
	{
		real = r; image = i;
	}
	friend void inputcomplex(Complex &comp);
	friend Complex addcomplex(Complex &c1, Complex &c2);
    friend Complex subcomplex(Complex &c1, Complex &c2);
	friend Complex mulcomplex(Complex &c1, Complex &c2);
	friend void outputcomplex(Complex &comp);
private:
	double real;
	double image;
};

void inputcomplex(Complex &comp)
{
	cin >> comp.real >> comp.image;
}

Complex addcomplex(Complex &c1, Complex &c2)
{
	Complex c;
	c.real = c1.real + c2.real;
	c.image = c1.image + c2.image;
	return c;
}

Complex subcomplex(Complex &c1, Complex &c2)
{
	Complex c;
	c.real = c1.real - c2.real;
	c.image = c1.image - c2.image;
	return c;
}

Complex mulcomplex(Complex &c1, Complex &c2)
{
	Complex c;
	c.real = c1.real * c2.real - c1.image * c2.image;
	c.image = c1.real * c2.image + c1.image * c2.real;
	return c;
}

void outputcomplex(Complex &comp)
{
	cout << "(" << comp.real << "," << comp.image << ")";
}

int main()
{
	Complex c1,c2,result;
	cout<<"       һ        ʵ     鲿:"<<endl;
	inputcomplex(c1);
	cout<<"      ڶ         ʵ     鲿:"<<endl;
	inputcomplex(c2);
	result=addcomplex(c1,c2);
	outputcomplex(c1);
	cout<<"+";
	outputcomplex(c2);
	cout<<"=";
	outputcomplex(result);
	cout<<"\n-------------------------"<<endl;
	result=subcomplex(c1,c2);
	outputcomplex(c1);
	cout<<"-";
	outputcomplex(c2);
	cout<<"=";
	outputcomplex(result);
	cout<<"\n-------------------------"<<endl;
	result=mulcomplex(c1,c2);
	outputcomplex(c1);
	cout<<"*";
	outputcomplex(c2);
	cout<<"=";
	outputcomplex(result);
	cout<<endl;

	return 0;
}

由于篇幅过长不利于拖拽，所以另起一篇。

muse journal

关注

27
点赞
踩
44

收藏

觉得还不错? 一键收藏
0
评论
C++面向对象程序设计（Visual C++2010版）课本例题源程序（上）

目录 6第1章　绪论 11第2章　C++语言对C语言的扩充 26第3章　类和对象 53第4章　友元 112习题 128第5章　继承与派生 129第6章　多态性和虚函数 170第7章　C++语言的输入输出流库 215第8章　异常处理 243第9章　Windows编程基础和MFC编程基础 254第10章　对话框和控件 297第11章　菜单和文档/视图结构 347第12章　图形设备接口 361正文结束 373附录A　程序的调试与运行 374。
复制链接

扫一扫