楔子: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 !