例5.1
分析下面程序中析构函数与构造函数的调用顺序。
#include<iostream> using namespace std; class object
{
private:
int val;
public:
object() :val()
{
cout << "Ddfault constructor for object" << endl;
}
object(int i) :val(i)
{
cout << "Constructor for object " << val << endl;
}
~object()
{
cout << "Destructor for object" << val << endl;
}
}; class container
{
private:
object one;//初始化顺序与对象成员产生的顺序有关
object two;//排在前面的先初始化
int data;
public:
container() :data()
{
cout << "Ddfault constructor for object" << endl;
}
container(int i, int j, int k);
~container()
{
cout << "Destructor for object" << data << endl;
}
}; container::container(int i, int j, int k) :two(i), one(j)//与初始化列表顺序无关
{
data = k;
cout << "Constructor for container " << data << endl;
} void main()
{
container obj, anObj(, , ); system("pause");
}
例5.2
分析下面程序的输出结果。
class Test
{
static int x;//静态数据成员
int n;
public:
Test()
{ }
Test(int a, int b)
{
x = a;
n = b;
}
static int func()
{
return x;//静态成员函数
};
static void sfunc(Test&r, int a)
{
r.n = a;//静态成员函数
}
int Getn()
{
return n;//非静态成员函数
}
}; int Test::x = ;//初始化静态数据成员 #include<iostream> using namespace std; void main()
{
cout << Test::func();//x在产生对象之前即存在，输出25 Test b, c;
b.sfunc(b, );//设置对象b的数据成员n cout << " " << b.Getn();
cout << " " << b.func();//x属于所有对象，输出25
cout << " " << c.func();//x属于所有对象，输出25 Test a(, );//将类的x值改为24 cout << " " << a.func() << " " << b.func() << " " << b.func() << endl; system("pause");
}
5.3
使用静态对象的例子
#include<iostream> using namespace std; class test
{
private:
int n;
public:
test(int i)
{
n = i;
cout << "constructor:" << i << endl;
}
~test()
{
cout << "destructor:" << n << endl;
}
int getn()
{
return n;
}
void inc()
{
++n;
}
}; void main()
{
cout << "loop start:" << endl; for (int i = ; i < ; i++)
{
static test a();
test b();
a.inc();
b.inc();
cout << "a.n=" << a.getn() << endl;
cout << "b.n=" << b.getn() << endl;
} cout << "loop end." << endl;
cout << "Exit main()" << endl; system("pause");
}
例5.4
使用友元函数计算两点距离的例子。
#include <iostream>
#include <cmath>//也可以使用头文件<math.h>
using namespace std;
class Point
{
private:
double X, Y;
public:
Point(double xi, double yi)
{
X = xi, Y = yi;
}
double GetX()
{
return X;
}
double GetY()
{
return Y;
}
friend double distances(Point&, Point&);//声明友元函数
};
double distances(Point& a, Point& b)//像普通函数一样定义友元函数
{
double dx = a.X - b.X;//可以访问对象a的成员
double dy = a.Y - b.Y;//可以访问对象b的成员
return sqrt(dx*dx + dy*dy);
}
void main()
{
Point p1(3.5, 5.5), p2(4.5, 6.5);
cout << "The distance is " << distances(p1, p2) << endl; system("pause");
}
例5.5
类One的对象通过友元函数访问类Two的对象的私有数据。
#include <iostream>
using namespace std;
class Two;//先声明类Two以便类One引用Two&
class One
{
private:
int x;
public:
One(int a)
{
x = a;
}
int Getx()
{
return x;
}
void func(Two&);//声明本类的成员函数，参数为Two类的引用
};
class Two
{
private:
int y;
public:
Two(int b)
{
y = b;
}
int Gety()
{
return y;
}
friend void One::func(Two&);//声明类One的函数为友元函数
};
void One::func(Two& r)//定义类One的函数成员
{
r.y = x;//修改类Two的数据成员
}
void main()
{
One Obj1();
Two Obj2();
cout << Obj1.Getx() << " " << Obj2.Gety() << endl;
Obj1.func(Obj2);
cout << Obj1.Getx() << " " << Obj2.Gety() << endl; system("pause");
}
例5.6
类One的对象可以通过任意一个成员函数访问类Two的对象的私有数据。
#include <iostream> using namespace std; class Two
{
int y;
public:
friend class One;
}; class One
{
int x;
public:
One(int a, Two&r, int b)
{
x = a;
r.y = b;
}
void Display(Two&);
}; void One::Display(Two&r)
{
cout << x << " " << r.y << endl;
} void main()
{
Two Obj2;
One Obj1(, Obj2, );
Obj1.Display(Obj2); system("pause");
}
例5.7
常数据成员初始化和常引用作为函数参数。
#include <iostream> using namespace std; class Base
{
private:
int x;
const int a;//常数据成员只能通过初始化列表来获得初值
static const int b;//静态常数据成员
const int& r;//常引用只能通过初始化列表来获得初值
public:
Base(int, int);
void Show()
{
cout << x << "," << a << "," << b << "," << r << endl;
}
void Display(const double& r)
{
cout << r << endl;
}
}; const int Base::b = ;//静态常数据成员在类外初始化 Base::Base(int i, int j) :x(i), a(j), r(x)//初始化列表
{ } void main()
{
Base a1(, ), a2(, );
a1.Show();
a2.Show();
a2.Display(3.14159);//常引用作为函数参数 system("pause");
}
例5.8
const对象调用const成员函数。
#include <iostream> using namespace std; class Base
{
private:
double x, y;
const double p;
public:
Base(double m, double n, double d) :p(d)//通过初始化列表来获得初值
{
x = m;
y = n;
}
void Show();
void Show() const;
}; void Base::Show()
{
cout << x << "," << y << " p=" << p << endl;
} void Base::Show() const//定义时必须也使用const
{
cout << x << "," << y << " const p=" << p << endl;
} void main()
{
Base a(8.9, 2.5, 3.1416);
const Base b(2.5, 8.9, 3.14);
b.Show();//调用void Show() const
a.Show();//调用void Show() system("pause");
}
例5.9
const函数返回的常量对象与其他常量对象一起使用。
#include <iostream> using namespace std; class ConstFun
{
public:
int f5() const
{
return ;//返回常量对象
}
int Obj()
{
return ;
}
}; void main()
{
ConstFun s;//一般对象
const int i = s.f5();//对象s使用f5()初始化常整数
const int j = s.Obj();//对象s使用Obj()初始化常整数
int x = s.Obj();//对象s使用Obj()作为整数
int y = s.f5();//对象s使用f5()作为整数 cout << i << " " << j << " "//输出5和45
<< x << " " << y;//输出45和5 const ConstFun d;//const对象
int k = d.f5();//常量对象d只能调用常成员函数 cout << " k=" << k << endl;//输出5 system("pause");
}
例5.10
使用类对象数组和指针的例子。
class Test
{
int num;
double f1;
public:
Test(int n)//一个参数的构造函数
{
num = n;
}
Test(int n, double f)//两个参数的构造函数
{
num = n;
f1 = f;
}
int GetNum()
{
return num;
}
double GetF()
{
return f1;
}
}; #include <iostream> using namespace std; void main()
{
Test one[] = { , }, *p;
Test two[] = { Test(,3.2),Test(,9.5) }; for (int i = ; i < ; i++)//输出对象数组对象
{
cout << "one[" << i << "]=" << one[i].GetNum() << endl;
} p = two;//使用指针输出对象数组元素 for (int i = ; i < ; i++, p++)
{
cout << "tow[" << i << "]=(" << p->GetNum() << ","
<< p->GetF() << ")" << endl;
} system("pause");
}
例5.11
仍然使用类Test，但改用对象指针数组的演示主程序。
class Test
{
int num;
double f1;
public:
Test(int n)//一个参数的构造函数
{
num = n;
}
Test(int n, double f)//两个参数的构造函数
{
num = n;
f1 = f;
}
int GetNum()
{
return num;
}
double GetF()
{
return f1;
}
}; #include <iostream> using namespace std; void main()
{
Test *one[] = { new Test(),new Test() };
Test *two[] = { new Test(,3.2),new Test(,9.5) }; for (int i = ; i < ; i++)//输出对象数组对象
{
cout << "one[" << i << "]=" << one[i]->GetNum() << endl;
} for (int i = ; i < ; i++)
{
cout << "tow[" << i << "]=(" << two[i]->GetNum() << ","
<< two[i]->GetF() << ")" << endl;
} system("pause");
}
求解一元二次方程
头文件
equation.h
源文件
equation.cpp
源文件
Find.cpp
头文件
equation.h
#if ! defined(EQUATION_H)
#define EQUATION_H
#include<iostream>
#include<cmath>
using namespace std;
//***************************
//* 先声明FindRoot类 *
//***************************
class FindRoot
{
private:
float a, b, c, d;
double x1, x2;
public:
FindRoot(float x, float y, float z);
void Find();
void Display();
};
#endif
源文件
equation.cpp
#include"equation.h"
//***************************
//* 实现FindRoot类 *
//***************************
FindRoot::FindRoot(float x, float y, float z)//构造函数
{
a = x;
b = y;
c = z;
d = b*b - * a*c;
} void FindRoot::Find()//实现成员函数Find
{
if (d > )
{
x1 = (-b + sqrt(d)) / ( * a);
x2 = (-b - sqrt(d)) / ( * a);
return;
}
else if (d == )
{
x1 = x2 = (-b) / ( * a);
return;
}
else
{
x1 = (-b) / ( * a);
x2 = sqrt(-d) / ( * a);
}
} void FindRoot::Display()//实现成员函数Display
{
if (d > )
{
cout << "X1=" << x1 << "\nX2" << x2 << endl;
return;
}
else if (d == )
{
cout << "X1=X2=" << x1 << endl;
return;
}
else
{
cout << "X1=" << x1 << "+" << x2 << "i" << endl;
cout << "X2=" << x1 << "-" << x2 << "i" << endl;
}
}
源文件
Find.cpp
#include"equation.h" void Read(float&, float&, float&);//参数使用对象引用方式 void main()
{
float a, b, c; cout << "这是一个求方程ax2+bx+c=0的根的程序。" << endl; for (;;)//循环求解
{
Read(a, b, c);//准备系数 if (a == )//根据输入系数a决定是否结束for循环
{
return;
} FindRoot obj(a, b, c);//建立对象obj obj.Find();//求解
obj.Display();//输出计算结果
}//endfor
} void Read(float& a, float& b, float& c)//准备系数
{
cout << "输入方程系数a:"; cin >> a; if (a == )//系数a为零，则退出Read函数
{
getchar();//为了消除回车的影响
return;//将a=0返给for循环并退出Read函数
} cout << "输入方程系数b:";
cin >> b; cout << "输入方程系数c:";
cin >> c;
}