1月17日上课笔记

1、自定义类型用拷贝构造函数，初始列表即使不写，也会初始化，只不过是随机值

2、构造函数都可以使用初始化列表初始化（构造函数，拷贝构造函数），赋值运算符重载无初始化列表初始化，因为对象已经存在

3、const修饰的是*this（所指向的对象），而不是this

4.&运算符重载，要用两个const修饰

5、inline在短的函数中经常使用

6、为什么要替换#defind

（1）无类型安全性检查，int a=float b,出错，不知道类型

（2）容易出错，例如：Add a+b；a+b*c

7.友元

void Display(const Date& d)
{
	count << d._year << endl;
}

int main()
{
	Date d1;
	Display(d1);//错误，要定义为成员函数，才可以访问成员
}

定义为友元函数就可以使用

class Date
{
	friend void Display(const Date& d)；//声明
};
void Display(const Date& d)//定义
{
	count << d._year << endl;
}

现在就可以继续使用了，友元不是成员函数，是全局函数，可以访问其中的成员

8、<<运算符的重载

（1）

class Date
{
	friend void Display(const Date& d);
public:
	void operator<<(ostream& out)//count的别名，count可以输出基本类型，但是
	{								//不能输出自定义类型
		out << _year << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1 << count;//--->d1.operator<<(count);全局输出对象（count）可以直接使用
}

与count<<不太一样，同时不支持连续输出

所以定义全局函数

（2）友元不能重载

9、重载运算符cin>>

同样的道理

但是Date& d不能添加const

istream和ostream都定义在头文件<iosrtream>中

10、友元类

Date中访问Time中所有成员

Date访问Time，Date声明为Time的友元

在Time中加入friend class Date;

注意：

友元一定程度上破坏了C++的封装，友元不宜多用，在恰当的地方使用友元。

void Display()
{
	count << _t << endl;//输出要重载，并且要声明为Time的友元
}

11、一般配合使用

void Display()//定义为Date的友元
{
	;
}
ostream& operator<<(otream & out, const Date& d)
{
	out << d._year << d, _month << endl;
	out << d, _t << endl;//调用Time输入输出Time的友元
}

一、静态成员

1. 静态成员：共享

2. 限制：

（1）作用域：类域中可见

（2）访问限定符的限制

2.类中声明：static int Scount;

类外定义：int Date::Scount=0;

3.访问方式：

（1）错误

int main()
{
	Date d;
	d.Scount = 1;//不可以，因为private，要改为公有
}

（2）

int main()
{
	Date d;
	Date::Scount = 2;
}

（3）静态的为全局拥有

int main()
{
	Date d1, d2;
	d1.Scount = 1;
	Date::Scount = 2;
	count << d1, Scount << d2.Scount << endl;//答案为2，d1不是Scount的唯一拥有者
}

2、static int Scount定义为私有；

在类中访问；

Date()
{
	++Scount;//作用：构造函数调了多少次
}
int main()
{
	Date d1, d2;
	return 0;
}

如果要在类外访问，可以通过公有函数来访问

二。静态成员函数

问题：

（1）静态成员函数可以访问非静态的成员吗？

答:不能，无this指针

（2）非静态的成员函数可以访问静态成员吗？

答：能，只要突破域，可以不用this指针

为什么要定义static成员变量？

答：因为是围绕封装，继承，多态

封装是指（1）数据和方法分开，访问限定，要访问接口

static要封装生命周期是全局的

三、编译器的优化

1.

2、

3、

4.

运用

Complex operator+(const Complex& x)
{
	Complex tmp;
	tmp._real = 1;
	return tmp;
}
int main()
{
	Complex ret;
	ret = c1 + c2;//不够高效

	Complex ret = c1 + c2;//更高效
}

5、

6、

但是

Complex operator+(const...)
{
	return Complex(this->real+...)
}//更加优化

7、

转载于:https://blog.51cto.com/10742910/1736085