C++示例编程1

Complex类--复数类

1、inline内联函数

inline double

imag(const complex& x)

{

return x.imag();

}

内联函数是指将函数时内嵌到函数的调用处

使用内联函数的优点是可以节省程序运行的时间，因为省去了调用函数的堆栈的切换以及分配等操作，相当于用空间换取时间，但是一般直将代码行数在10行以内的简单函数作为内联使用，因为大型的函数如果展开，会增大代码的大小，反而减慢程序的运行，但是即使我们加上inline选项，编译器也不一定会为我们生成内联，编译器会自己判断是否将这个函数作为内联函数

2、构造函数

complex (double r = 0,double i = 0):

re(r),im(i) {}

构造函数的参数是可以有初值的，当声明类时没有参数，就会调用默认参数的构造函数

然后是构造函数的赋值，可以使用初始列（initialize list）这样可以提高效率，因为省去了在函数体内做赋值的事件，而是将赋值完成在了函数体之前

一种特殊的情况（ctor in private）-将构造函数放在private里

class A {

public:

static A& getInstance();

setup() { ... }

private:

A();

A(const A& rhs);

...

};

A& A::getInstance()

{

static A a;

return a;

}

可以通过提供一个额外的接口来实现，并且声明的是一个静态的对象，这样可以保证整个内存中只有一个类对象，而且访问的时候可以通过类直接访问，比如A::a

3、常量成员函数与常量参数

double real () const { return re; }

double imag () const { return im; }

如果不希望一个函数改变某个变量的值，那么可以在函数后面加上一个const修饰，来保证他不会修改变量的值，举一个例子

class complex

{

....

double real() {

re = 1234;

return re;

}

}

...

const complex(1,2);

complex.real();

这里定义了一个常量对象，但是我们在调用它的成员变量的时候对他进行了修改，这就有可能会发生错误，所以在编写函数的时候要注意这一点

friend complex& __doapl (complex*, const complex&);

还有就是常量参数，常量参数用于保护参数不被改变，因为在编写函数的时候可能会对参数进行有意无意的改变，加上const修饰可以很好地避免这一点

4、传值和传引用

double real () const { return re; }

double imag () const { return im; }

 

friend complex& __doapl (complex*, const complex&);

 

ostream&

operator << (ostream& os, const complex& x)

{

return os << '(' << real (x) << ','

<< imag (x) << ')';

}

在编写函数的返回值和参数时，一般都有传值和传引用两种方式，一般的建议都是如果可以用传引用，就尽量使用传引用，因为引用只有四个字节，传递的速度比较快，但是在传递返回值的时候要注意，如果返回值是一个局部变量，那么就不可以传引用，因为在函数返回时，局部变量已经被释放了，这样传回去的就是空

还有一点就是在重载操作符的时候，返回值是流操作符，在特定情况下，有时返回void也可以，比如是重载赋值操作符，如果只有一步赋值，可以返回void，但是如果是连续赋值，则不可以

complex r1,r2,r3;

r1 = r2; //重载=可以返回void

r1 = r2 = r3;//重载=不可以返回void，要返回ostream&

重载流操作符时，还有一点，就是流操作符参数不可以用const修饰，因为输出时会改变ostream的状态

5、临时变量-temp object

举一个重载操作符的例子

inline complex

operator + (const complex& x, const complex& y)

{

return complex (real (x) + real (y),

imag (x) + imag (y));

}

在重载+号时，我们使用了临时变量这个特性，它的特点是在表达式结束后，它就会被销毁，这里用它来传递两个复数相加之后的结果，而且这里返回使用的是值传递而不是引用传递，因为临时变量马上就会被销毁，如果使用引用传递，传递的就是空值

整体的示例代码

complex.h

#ifndef __COMPLEX__

#define __COMPLEX__

class complex

{p

ublic:

complex (double r = 0, double i = 0)

: re (r), im (i)

{ }

complex& operator += (const complex&);

double real () const { return re; }

double imag () const { return im; }

 

private:

double re, im;

friend complex& __doapl (complex*,

const complex&);

};

inline complex&

__doapl(complex* ths, const complex& r)

{

ths->re += r.re;

ths->im += r.im;

return *ths;

}

inline complex&

complex::operator += (const complex& r)

{

return __doapl (this, r);

}

complex ( real (x) + real (y),

imag (x) + imag (y) );

}

inline complex

operator + (const complex& x, double y)

{

return complex (real (x) + y, imag (x));

}

inline complex

operator + (double x, const complex& y)

{

return complex (x + real (y), imag (y));

}

45

#include <iostream.h>

ostream&

operator << (ostream& os,

const complex& x)

{

return os << '(' << real (x) << ','

<< imag (x) << ')';

}

 

#endif