搬运自大神博客
Class without pointer members (class complex)
1. 防卫式声明
#ifndef _COMPLEX_
#define _COMPLEX_
......
#endif
2. inline function
函数若在class体内完成定义，则自动成为内联函数候选人； 若在class外,需添加inline关键字;同时真正是否inline由编译器决定。
class complex{
public:
complex (double r = 0, double i = 0):re(r), im(i){} //inline
complex& operator += {const complex&};
double real() const{return re;} //inline
double imag() const{return im;} //inline
private:
double re,im;
friend complex& _doap1 (complex*, const complex);
};
inline double imag(const complex& x){ //inline
return x.imag();
}
3. 访问级别
private: 数据部分，封装，不被外界（class外）访问。
public: 可以被外界访问（class外）的。
定义时不一定集中在两段，可以根据实际情况交替使用两个关键字。
4. 构造函数
创建对象是调用构造函数，函数名与类名相同，无返回值类型。
下述三种创建对象方式均调用构造函数
class complex{
public:
complex (double r = 0, double i = 0):re(r), im(i) {} //可以带参数，参数可以有默认值，即未指明时使用默认值
//初始化列表 : re(r),im(i) 能使用初始化列表时尽量使用
complex& operator += {const complex&};
double real() const{return re;}
double imag() const{return im;}
private:
double re,im;
friend complex& _doap1 (complex*, const complex);
};
{
complex c1(2,1); //三种方式均调用构造函数
complex c2;
complex *p = new complex(4);
...
}
构造函数在private 区域
不能被外界调动，例如在单例模式中使用
class A{
public:
static A& getInstance(); //静态类型变量
setup(){}
private:
A(); //构造函数在private区域
A(const A& ths);
...
};
A& A::getInstance(){
static A a;
return a;
}
A::getInstance().setup(); //使用时利用类的getInstace()函数
5. 重载
同名函数可以存在，判断是否可以重载即判定编译器是否能区分两种函数使用。
double real() const {return re;}
void real(double r) {re = r;} //正确重载
complex(double r= 0, double i = 0): re(r),im(i) {};
complex() : re(r), im(i){}; // 错误，编译器无法判断， 如： complex c1; 不知道调用哪个。
6. const member functions
注意const functions中 const 的位置： 函数名之后，函数体之前
double real() const{return re;}
double imag() const{return im;}
//不改变数据内容，则一定要加const，否则可能引起错误，如：
//外界调用该函数时 使用：const complex c1(1,2);
//声明常对象，常对象不可调用非常成员函数，出现错误
7. pass by value or pass by reference (to const)
传值会造成开销较大（基本类型可以传值），能传引用时尽量传递引用（开销仅4bytes）。
如果不想给予对方修改权限，则使用const关键字 如 const complex& 为常见形式。
class complex{
public:
complex (double r = 0, double i = 0):re(r), im(i){} //pass by value
complex& operator += {const complex&}; //pass by reference
double real() const{return re;}
double imag() const{return im;}
private:
double re,im;
friend complex& _doap1 (complex*, const complex&); //pass by reference
};
8. return by value or return by reference
尽量传递引用，不可以情况参考后 8.1 和临时变量章节
complex& operator += {const complex&};
friend complex& __doapl (complex*, const complex&);
8.1 什么时候可以return by reference
函数运算返回结果
1）必须在函数内新创建对象，不能返回reference，因为函数结束时，对象消亡，引用指向的本体已经不在。
2）当返回结果是已经存在的对象，可以返回引用，常见情况this指针
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);
}
8.2 pass/ return by reference 语法分析
传递者无需知道接收端以何种形式进行接收；
如下例，返回传递仅需传递原值，接收者自己决定接收引用或接受值（调用拷贝构造）。
inline complex&
__doapl(complex* ths, const complex& r)
{
ths->re += r.re;
ths->im += r.im;
return *ths;
}
9. 友元（friend）
friend complex& __doapl (complex*, const complex&);
inline complex&
_doap1 (complex* ths, const complex& r){
ths->re += r.re; //自由取得friend的private变量，但破坏封装
ths->im +=r.im;
return *ths;
}
9.1 相同类（class）的各个对象（objects）之间互为友元
class complex{
public:
complex (double r = 0, double i = 0):re(r),im(i){
}
int func(const complex& param){
return param.re + param.im；
} //直接拿param私有变量，可以用相同类的各个对象之间互为友元解释
private:
double re, im;
};
10. 运算符重载1 成员函数（operator overloading）
二元操作符被编译器看待的形式：（注意是看待形式，this存在可以使用，但参数列表中this不可写出）this指向调用者
二元操作符
实际代码如下：
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) //operator += 在程序员使用时可能采用c1 += c2 += c3形式
// 故需要返回complex&类型，不能是void, 类似还有重载cout返回类型
{
return __doapl (this, r)
}
11. 运算符重载2 非成员函数(无this指针)
全局函数，无this指针.
例如此复数类，重载加减等符号时，存在复数加减实数情况，故不宜使用成员函数。
inline complex
operator + (const complex& x, const complex& y)
{
return complex (real (x) + real (y),
imag (x) + imag (y)); //返回的是函数内临时变量（local object），函数结束后消亡，故不可使用return by reference
}
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));
}
流操作符重载：
#include
ostream& //返回的一定是引用，要不然不能连接多个<<
operator << (ostream& os, const complex&){ //两个参数为 << 左边和右边，如 cout << c1; cout类型为ostream,
return os << '(' << real(x) << ','
<< imag(x) << ')';
}
12. complex 类完整代码 与测试代码
complex.h
#ifndef __MYCOMPLEX__
#define __MYCOMPLEX__
class complex;
complex&
__doapl (complex* ths, const complex& r);
complex&
__doami (complex* ths, const complex& r);
complex&
__doaml (complex* ths, const complex& r);
class complex
{
public:
complex (double r = 0, double i = 0): re (r), im (i) { }
complex& operator += (const complex&);
complex& operator -= (const complex&);
complex& operator *= (const complex&);
complex& operator /= (const complex&);
double real () const { return re; }
double imag () const { return im; }
private:
double re, im;
friend complex& __doapl (complex *, const complex&);
friend complex& __doami (complex *, const complex&);
friend complex& __doaml (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);
}
inline complex&
__doami (complex* ths, const complex& r)
{
ths->re -= r.re;
ths->im -= r.im;
return *ths;
}
inline complex&
complex::operator -= (const complex& r)
{
return __doami (this, r);
}
inline complex&
__doaml (complex* ths, const complex& r)
{
double f = ths->re * r.re - ths->im * r.im;
ths->im = ths->re * r.im + ths->im * r.re;
ths->re = f;
return *ths;
}
inline complex&
complex::operator *= (const complex& r)
{
return __doaml (this, r);
}
inline double
imag (const complex& x)
{
return x.imag ();
}
inline double
real (const complex& x)
{
return x.real ();
}
inline complex
operator + (const complex& x, const complex& y)
{
return 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));
}
inline complex
operator - (const complex& x, const complex& y)
{
return 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));
}
inline complex
operator * (const complex& x, const complex& y)
{
return complex (real (x) * real (y) - imag (x) * imag (y),
real (x) * imag (y) + imag (x) * real (y));
}
inline complex
operator * (const complex& x, double y)
{
return complex (real (x) * y, imag (x) * y);
}
inline complex
operator * (double x, const complex& y)
{
return complex (x * real (y), x * imag (y));
}
complex
operator / (const complex& x, double y)
{
return complex (real (x) / y, imag (x) / y);
}
inline complex
operator + (const complex& x)
{
return x;
}
inline complex
operator - (const complex& x)
{
return complex (-real (x), -imag (x));
}
inline bool
operator == (const complex& x, const complex& y)
{
return real (x) == real (y) && imag (x) == imag (y);
}
inline bool
operator == (const complex& x, double y)
{
return real (x) == y && imag (x) == 0;
}
inline bool
operator == (double x, const complex& y)
{
return x == real (y) && imag (y) == 0;
}
inline bool
operator != (const complex& x, const complex& y)
{
return real (x) != real (y) || imag (x) != imag (y);
}
inline bool
operator != (const complex& x, double y)
{
return real (x) != y || imag (x) != 0;
}
inline bool
operator != (double x, const complex& y)
{
return x != real (y) || imag (y) != 0;
}
#include
inline complex
polar (double r, double t)
{
return complex (r * cos (t), r * sin (t));
}
inline complex
conj (const complex& x)
{
return complex (real (x), -imag (x));
}
inline double
norm (const complex& x)
{
return real (x) * real (x) + imag (x) * imag (x);
}
#endif //__MYCOMPLEX__
complex.h
测试代码：
#include <iostream>
#include "complex.h"
using namespace std;
ostream&
operator << (ostream& os, const complex& x)
{
return os << '(' << real (x) << ',' << imag (x) << ')';
}
int main()
{
complex c1(2, 1);
complex c2(4, 0);
cout << c1 << endl;
cout << c2 << endl;
cout << c1+c2 << endl;
cout << c1-c2 << endl;
cout << c1*c2 << endl;
cout << c1 / 2 << endl;
cout << conj(c1) << endl;
cout << norm(c1) << endl;
cout << polar(10,4) << endl;
cout << (c1 += c2) << endl;
cout << (c1 == c2) << endl;
cout << (c1 != c2) << endl;
cout << +c2 << endl;
cout << -c2 << endl;
cout << (c2 - 2) << endl;
cout << (5 + c2) << endl;
return 0;
}
complex_test
