『C++学习录』C++程序设计

楔子：D

如果是晚自习
定会把七月在野八月在宇
挂在嘴边
可偏偏是2020的暑假了
我和时间真没默契

C++程序设计

一、作用域与可见性

1.标识符的作用域

1）函数原型的作用域

始于(，终于)，是最小的作用域

2）程序块作用域

限于块中

3）类作用域

成员函数中直接访问，函数中声明了同名局部标识符则需要加限定符

外部在作用域内通过表达式访问public成员（x.M/x::M/ptr->M)

（不加限定符就是邻近的，加限定符就是全局的）

void f2();
class x
{
public:
	int M;
	void f1();
	void f2();
public:
	void abc(void)
	{
		M = 1;//类成员 M
		f1();
		{
			int M;
			M = 2;//邻近的M
			X::M = 3;//this->M,类成员M
			f2();//X::f2()，类成员函数
			::f2();//全局f2()
		}
	};
}

4）文件作用域

不在前述各个作用域出现的标识符的声明

标识符的作用域始于声明点，终于文件尾

2.可见性

从内层作用域向外层作用域看

二、对象的生存期

1.对象的生存期

对象创建到撤销的时间

2.静态生存期

1）与程序运行期相同

2）文件作用域中声明的对象（全局变量）具有静态生存期

3）函数内部声明静态生存期对象，冠以关键字static

4）对象生存期结束，调用析构函数

...
int i;//文件作用域，静态生存期，全局变量
void foo(void
{
	static int j = 0;//块作用域，静态生存期，冠以static关键字
	j++;
}

int main()
{
	i++;
	foo();//第一次调用j = 1,再次调用时，j!=0,j=1
	return 0;
}

3.动态生存期

1）动态生存期对象

块作用域中声明，不修饰或者用auto修饰的对象

局部生存期对象

始于声明点，终于标识符作用域结束处

动态对象生存期结束，调用析构函数

...
int i = 1;//全局变量，静态生存期，文件作用域
int main()
{
static int a = 0;//局部静态变量，全局寿命
int b = -10;//局部变量，动态生存期
i = i+10;
void other(void);//声明
other();//第一次调用，
other();//第二次调用，a保持上次运行a=4,b保持上次b=4,c初始化为c=10
...
}
void other(void)
{
static int a = 2;//局部静态变量，全局的寿命
static int b;//局部静态变量，全局寿命
int c = 10;//局部动态变量
a = a+2;//邻近的a，不是主函数的a
b = a;//邻近的b，不是主函数的b
...
}

三、数据与函数

1.面向过程

数据存储在局部对象中，函数之间传参，返回结果

数据存储在全局对象中，函数处理全局对象，结果保存在全局对象中

2.面向对象

数据和使用数据的函数封装在类中，使用类的对象解决问题

四、静态成员

1.静态数据成员

static声明

类的所有对象维护该成员的同一个拷贝

类外定义和初始化，：：指明所属类

静态数据成员不属于任何一个对象

2.静态成员函数

只能引用属于该类的静态数据成员和静态成员函数

class A
{
	public:
		static void f();
		static void g();
		void h();
	private:
		static int s;
		int x;
};

void A::f()
{
	cout<<s;
	g();
	
	cout<<x;//错误，静态函数只能访问静态成员变量
	h();//错误，静态函数只能访问静态成员函数
	A.a;//实例化对象
	a.h();//可以访问实例化对象的非静态成员
	...
}

五、前向引用声明

class B;//前向引用声明
class A
{
public:
	void f(B b);
};
class B
{
public:
	void g(A a);
};

使用前向引用声明时，不能涉及类的实现细节，因为此时类还未被定义。

六、常量类型

1.

常量型的变量（对象）必须初始化，不能被更新，不能作为左值

1）常量引用

const 类型说明符 & 引用名

2）常量对象

类名 const 对象名

3）常量数组

类型说明符 const 数组名【大小】

4）常量指针

const int x = 100;//常量型变量
x++//错误

int a;
int &ra = a;
a = 1;
ra = 2;
cout << a << endl;//a = 2
const int &cra = a;//常量引用
cra = 3;//错误

#常量引用做形参，不能更新引用对象，提高安全性，防止修改

2.const

1)const修饰符

int const i <=> const int i

int const &r = const int &r

int const *p = const int *p

2)const修饰指针

指向常量的指针 ，指针指向的内容不能修改

const int *p1 = &a

指针类型的常量，指针指向的地址不能修改

int * const p2 = &a

指针指向的地址和内容都不能修改

const int * const p3 = &a

3)const修饰对象成员

a.常数据成员

const 数据成员

b.常成员函数

常成员函数不得调用非常量成员函数

类型说明符 函数名（参数表） const

#使用常量对象时，只能调用常成员函数

...
class R
{
public:
...
	void print()；
	void print() const;
private:
	...
};
void R::print()
{。。。}
void R::print() const
{。。。}
int main()
{
R a(5,4);
a.print();//调用Print()

const R b(20,52);//对象b是常对象
b.print();//调用print() const
}

尾巴：D

Ice Cube 
See U tonight !