c++经典代码大全

cout<<\ cout<

//以下直接访问对象的数据成员 a.value=200; cout<<\ cout<

#include // ex_class类接口定义 class ex_class {

private: int iv; double dv; public:

ex_class(void);

ex_class(int n,double x);

void set_ex_class(int n,double x); void show_ex_class(char*); };

//定义ex_class类的构造函数

ex_class::ex_class(void):iv(1), dv(1.0) { }

ex_class::ex_class(int n,double x):iv(n), dv(x) { }

//定义ex_class类的成员函数

void ex_class::set_ex_class(int n,double x) {

iv=n; dv=x; }

void ex_class::show_ex_class(char *name) {

cout<

//使用ex_class类 void main(void) {

ex_class obj1;

obj1.show_ex_class(\ obj1.set_ex_class(5,5.5); obj1.show_ex_class(\

ex_class obj2(100,3.14); obj2.show_ex_class(\ obj2.set_ex_class(2000,1.732); obj2.show_ex_class(\}

#include

//定义一个含有static数据成员的类 class ex {

static int num; //static数据成员 public:

ex() {num++;} ~ex() {num--;} disp_count() {

cout<<\ cout<

int ex::num=0; //设置static数据成员的初值 //main()函数测试ex类 main() {

ex a;

a.disp_count();

ex *p; p=new ex;

p->disp_count();

ex x[10];

x[0].disp_count();

delete p;

a.disp_count(); }

#include

//定义一个含有static数据成员的类 class ex {

static int num; //static数据成员 public:

ex() {num++;} ~ex() {num--;}

static disp_count(void) //static成员函数 {

cout<<\ cout<

int ex::num=0; //设置static数据成员的初值 //main()函数测试ex类 main() {

ex a;

a.disp_count();

ex *p; p=new ex;

p->disp_count();

ex x[10];

ex::disp_count(); //直接用类作用域符引用静态成员函数

delete p;

ex::disp_count(); //直接用类作用域符引用静态成员函数 }

#include class ex_class { int value; public:

ex_class(int n) { value=n;

cout << \ }

26

~ex_class() {

cout << \ }

void set_value(int n);

void show_val(char *name); } ;

//在类外定义内联成员函数

inline void ex_class::set_value(int n) { value=n; }

//在类外定义非内联成员函数

void ex_class::show_val(char *name) { cout<

//在main()函数中测试ex_class类 main(void) {

//创建对象x和y

ex_class x(100),y(200);

//显示对象的数据 x.show_val(\ y.show_val(\

//设置新值给对象 x.set_value(1); y.set_value(2);

//显示对象的数据 x.show_val(\ y.show_val(\

return 0; }

#include //定义空类empty class empty { };

//在main()函数中用空类创建对象 main() {

empty a,*p; //编译通过

cout<<\}

#include

//用struct关键字定义ex_class类 struct ex_class {

ex_class(int n=1): value(n) {} void set_value(int n) { value=n; }

show_obj(char *name) { cout<

int value; }

//测试 ex_class类 main() {

//用ex_class创建对象 ex_class a,b(3);

a.show_obj(\ b.show_obj(\

a.set_value(100); b.set_value(200);

a.show_obj(\ b.show_obj(\}

#include #include

//定义双亲（parent）类 class parent {

char f_name[20]; char m_name[20]; char tel[10]; public:

// parent类的构造函数，其带有缺省值

parent(char *p1=\ strcpy(f_name,p1); strcpy(m_name,p2); strcpy(tel,p3); }

//显示parent对象的数据 show_parent(void) {

cout<<\

cout<<\ father's name:\ cout<<\ mother's name:\ cout<<\ tel:\ } };

//定义student类 class student {

int num;

char name[20]; float grade; parent pt; public:

// student类的构造函数

student(int n,char *str,float g,class parent t) { num=n;

strcpy(name,str); grade=g; pt=t; }

//显示student对象的数据 show_student(void) {

cout<<\ cout<<\ cout<<\ pt.show_parent(); } };

//main()函数测试student类的对象

27

main(void) {

//创建双亲对象

parent p1(\ //创建学生对象

student st(10001,\

//显示学生信息 cout<<\ p1.show_parent();

//显示学生信息 cout<<\ st.show_student(); }

#include #include //定义timer类 class timer{ long minutes; public:

//定义重载成员函数 settimer(char *m) { minutes = atoi(m); };

//定义重载成员函数 settimer(int h, int m) { minutes = 60*h+m ; };

//定义重载成员函数 settimer(double h) {

minutes = (int) 60*h ; };

long getminutes(void) { return minutes; }; };

//main()函数的定义 main(void){

timer start,finish; //创建对象

//使用重载成员函数 start.settimer(8,30); finish.settimer(9,40); cout<<\ cout<

//使用重载成员函数 start.settimer(2.0);

finish.settimer(\ cout<<\ cout<

return 0; }

#include //定义复数类 class complex{

float real; //实部 float image; //虚部 public:

//重载的运算符\的原型

complex operator+ (complex right); //重载赋值运算符\的定义

complex operator= (complex right); void set_complex(float re, float im); void put_complex(char *name); };

//重载加法运算符\的定义

complex complex::operator+ (complex right) { complex temp;

temp.real = this->real + right.real;

temp.image = this->image + right.image; return temp; }

//重载加赋值运算符\的定义

complex complex::operator= (complex right) { this->real = right.real; this->image = right.image; return *this; }

//定义set_complex()成员函数

void complex::set_complex(float re, float im) { real = re; image = im; }

//定义put_complex()成员函数

void complex::put_complex(char *name) { cout<

if (image >= 0.0 ) cout << '+'; cout << image << \}

//在main()函数中使用complex类的对象 main(void) {

complex A, B, C; //创建复数对象

//设置复数变量的值 A.set_complex(1.2, 0.3); B.set_complex(-0.5, -0.8);

//显示复数数据

A.put_complex(\ B.put_complex(\

//赋值运算，显示结果 C = A;

C.put_complex(\

//加法及赋值运算，显示结果 C = A + B;

C.put_complex(\ return 0; }

// Example of the friend class #include //定义YourClass类， class YourClass {

//指定YourOtherClass是它的友元类

28

friend class YourOtherClass; private:

int num; public:

YourClass(int n){num=n;} display(char *YCname){

cout<

//定义YourOtherClass，它是YourClass类的友元类 class YourOtherClass {

public:

//使用YourClass类的私有成员

void disp1(YourClass yc,char *YCname){ cout<

//使用YourClass类的公共成员

void disp2(YourClass yc,char* YCname){ yc.display(YCname); } };

//在main()函数中创建和使用YourClass和YourOtherClass类对象

main(void) {

//声明YourClass类对象 YourClass a(10),b(100);

//显示a和b对象的值 cout<<\ a.display(\ b.display(\

//声明YourOtherClass类对象 YourOtherClass temp;

//通过temp显示a和b对象的值 cout<<\ temp.disp1(a,\ temp.disp2(b,\}

#include //Y类的不完全定义 class Y;

//X类的定义 class X { public:

void disp(Y py,char *name); //成员函数原型 };

//定义Y类 class Y {

//声明本类的友元函数

//X类的disp()为本例的友元函数 friend void X::disp(Y py,char *name); //普通函数putY() 为本例的友元函数

29

friend void putY(Y& yc,char *name); private: //私有成员 int num;

dispY(char *name){

cout<

public: //公共成员函数 Y(int n){ num=n; } };

//X类成员函数的实现部分 void X::disp(Y py,char *name){ cout<<\

py.dispY(name); //访问Y类的私有函数 }

//普通函数putY()的定义

void putY(Y& yc,char *name){ cout<<\ yc.dispY(name);

cout<

//在main()函数测试X和Y类的功能 main() {

//创建Y和X类的对象 Y y1(100),y2(200); X x;

//不可用Y类对象的私有成员函数显示 //y1.dispY(\ //y2.dispY(\

//调用X类对象的友元函数显示 x.disp(y1,\ x.disp(y2,\

//用getY函数显示Y类的对象显示 putY(y1,\ putY(y2,\}

#include //定义日期类 class Date {

//定义友元重载输入运算符函数

friend istream& operator >> (istream& input,Date& dt ); //定义友元重载输出运算符函数

friend ostream& operator<< (ostream& output,Date& dt ); int mo, da, yr; public:

Date(void){ //无参数构造函数 yr = 0; mo = 0; da = 0; }

Date( int y, int m, int d ) //带参数构造函数 {

yr = y; mo = m; da = d; } };

//定义\运算符重载函数

istream& operator >> ( istream& input, Date& dt ) {

cout<<\ input>>dt.yr; cout<<\ input>>dt.mo; cout<<\ input>>dt.da; return input; }

//定义\运算符重载函数

ostream& operator<< ( ostream& output, Date& dt ) {

output<< dt.yr << '/' << dt.mo << '/' << dt.da<

//在main()函数中测试Date类的插入（<<）和提取（>>）运算符

void main() {

//声明对象

Date dt1(2002,5,1),dt2;

//显示dt1对象 cout<

//对dt2对象进行输入和输出 cin>>dt2; cout<

#include //定义ex类 class ex_class {

int a;

double b; public:

ex_class(int n=1,double x=1.0):a(n),b(x) {} void show_value(char *name) { cout<

//定义main()函数 main() {

//创建ex_class的对象并显示 ex_class obj1,obj2(100,3.5);

30

obj1.show_value(\ obj2.show_value(\

//创建ex_class的指针变量 ex_class *p;

//p指向obj1并显示 p=&obj1;

p->show_value(\

//p指向obj2并显示 p=&obj2;

(*p).show_value(\

//p指向动态创建的对象并显示 p=new ex_class;

p->show_value(\

delete p; //删除对象 }

#include //基类Box class Box {

int width,height; public:

void SetWidth(int w) { width=w; }

void SetHeight(int h) { height=h; }

int GetWidth() {return width;} int GetHeight() {return height;} };

//派生类ColoredBox

class ColoredBox:public Box {

int color; public:

void SetColor(int c){ color=c; }

int GetColor() {return color;} };

// 在main()中测试基类和派生类 main(void) {

//声明并使用ColoredBox类的对象 ColoredBox cbox;

cbox.SetColor(3); //使用自己的成员函数 cbox.SetWidth(150); //使用基类的成员函数 cbox.SetHeight(100); //使用基类的成员函数

cout<<\

cout<<\ //使用自己的成员函数

cout<<\ //使用基类的成员函数

cout<<\ //使用基类的