C++学习记录（一）

类的声明

类的布局

class complea //前置声明

class complex{//class head
	......    //类的声明//class body
};

complex::function(){...}//类的定义

访问级别

共有三个。分别为 public,protected,private
public为公开级别，public公开的数据在任何地方都可以访问。
protected为半公开，只可以在类内和派生出的子类访问。
private为私有，仅可以在类内调用，且private为类内默认的访问级别，及不使用这三个关键字声明的变量默认为private

class complex
{
public:
  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&);
};
//以下为调用
{
	complex c1(2,1);//本例子为错误示范
	cout<<c1.re;//由于re为私有，在类外不可调用故编译器会报错
	cout<<c1.im;
}

{
	complex c1(2,1);//本例子为正确示范
	cout<<c1.real();
	//由于real函数为共有，在类外可以调用，且由于real为类内函数，可以访问private的re和im
	cout<<c1.imag();
}

构造函数

构造函数在创造对象时会自动调用
构造函数名与类名相同如下面例子中的

complex (double r = 0, double i = 0): re (r), im (i) { }

class complex
{
public:
  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&);
};

{
	complex c1(2,1);//创建一个值为2，1和对象
	complex c2;//创建一个无参的对象，由于本类的构造函数在没有传值的情况下有初始值，所以会创建一个值为0，0，的对象
	complex *p=new complex(4);//动态方式创建，new类似于c语言中的malloc
}

构造函数特点：
1.需要和类名相同
2.可以拥有参数，但是没有返回类型
3.参数可以拥有默认值，在没有传参的情况下将默认值赋给对象（任何函数都可以有默认值，析构除外，因为析构不可以加参数）
4，构造函数可以重载（重载：函数名相同，参数列表不同）

构造函数赋值方法

//方法1
 complex (double r = 0, double i = 0): re (r), im (i) { }
//方法2
 complex (double r = 0, double i = 0){ 
		re=r;
		im=i;
 }

方法1为构造函数独有，称为初始列，在函数括号后大括号前的地方，
格式为：被赋值的变量名（将要赋值的值，多数为传入的实参），多个参数由逗号隔开

单例模式

将构造参数放入private区域里，此类不可被外部创建

class A{
public:
	static A& getInstance();
	setup(){...}
private:
	A();
	A(const A& rhs);
};

A& A::getInstance(){
	static A a;
	return a;
}

常量成员函数

在如下位置加入const,常函数内部不会改变任何数据

  double real () const { return re; }
  double imag () const { return im; }

定义常对象时只可以调用常函数

class complex
{
public:
  complex (double r = 0, double i = 0): re (r), im (i) { }
  complex& operator += (const complex&);
  double real (){ return re; }
  double imag (){ return im; }
private:
  double re, im;

  friend complex& __doapl (complex *, const complex&);
};
//以下为示例1
{
	complex c1(2,1);
	cout<<c1.real();
	cout<<c1.imag();
}
//以下为示例2注意，以下两个函数在类内并没有定义为const,由于c1为const，所以调用real函数和imag函数时候会报错
{
	const complex c1(2,1);
	cout<<c1.real();
	cout<<c1.imag();
}

友元

被定义为友元的函数可以无限制访问和该便class内的值，及，类内一切对于友元都是public
相同class的各个对象互为友元

操作符重载

以下例子第三部分定义了两个对象，并且对对象相加，在编译器看来

c2+=c1
相当于
operator += (this,const complex& r)
其中this直指向c2,c1为r，及传进来的实参，但是注意，this为自带的变量，是一个指向调用对象本体的指针，不可在形参列表声明，可以在函数内调用。

//部分一
inline complex&
complex::operator += (const complex& r)
{
  return __doapl (this, r);
}
//部分二
inline complex&
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
//部分三
{
	complex c1(2,1);
	complex c2(5);
	c2+=c1;
}
 

重载函数在类内定义 格式为

operator 重载的符号（如+=）{...}
complex::operator += (const complex& r)
{
  return __doapl (this, r);
}