1. 局部变量初始化
const int SIZE = 5;
int funcStatic() {
static int a1;
static int a2(0); //初始化
static int a3 = 0; //初始化
static int a4(0);
a4 = 0;
cout <<"a1: "<<a1++<<" a2: "<<a2++<<" a3: "<<a3++<<" a4: "<<a4++<<endl;
return 0;
}
int func(){
int b_1(1),b_2 = 2;
char c[] = {'C','+','+'}; // 不含'\0'
char c_1[] = {'C','+','+','\0'};
char c_2[] = "C++"; // 默认追加'\0'
int d_1[SIZE]={1,2},d_2[]={1,2};
cout <<"b_1: "<<b_1<<" b_2: "<<b_2<<endl;
cout <<"sizeof(c) "<<sizeof(c)<<"\nsizeof(c_1) " \
<<sizeof(c_1)<<"\nsieof(c_2) "<<sizeof(c_2)<<endl;
cout <<"sieof(d_1) "<<sizeof(d_1) \
<<"\nsieof(d_2) "<<sizeof(d_2)<<endl;
cout <<"d_1[2] "<<d_1[2]<<endl;
return 0;
}
int main() {
func();
funcStatic();
funcStatic();
return 0;
}
/*
b_1: 1 b_2: 2
sizeof(c) 3
sizeof(c_1) 4
sieof(c_2) 4
sizeof(d) 20
sieof(d_1) 20
sieof(d_2) 8
d_1[2] 0
a1: 0 a2: 0 a3: 0 a4: 0
a1: 1 a2: 1 a3: 1 a4: 0
*/
1.1 静态变量
- 在固定的地址上进行存储分配，在静态数据区(static data area，又 数据段(data segment) )
- 具有局部可见性，内部链接
- 在第一次调用时初始化，且仅初始化一次，作用域外其值保持不变
- 内部类型静态变量，如果未初始化，则编译器默认初始化为０
1.2 常量
- c++中const默认为内部链接；c默认外部连接
- 初始化必须在定义点进行
const int a = 1;
const int d[]={1,2,3,4};
extern const int size = 5; //明确为外部连接
1.3 引用
- 引用被定义时必须初始化
- 引用不可变更
- 没有NULL引用
2. 类成员变量
class Test{
static constexpr int x[3]={1,2,3};
static int s;
const int a[3] = {1,2,3};
const int b = 1;
const int c;
const int d[2];
public:
Test():c(4), d({5,6}) {//warning
cout <<a[0]<<" "<<b<<" "<<c<<" "<<d[0]<<endl;
}
};
int Test::s = 1;
int main() {
Test tl;
return 0;
}
//test.cpp: In constructor ‘Test::Test()’:warning: list-initializer for non-class type must not be parenthesized [enabled by default]
//output
//1 1 4 5
2.1 静态成员
- 在类内定义，类外初始化
2.2 常量成员
- 初始化是在类的构造函数的初始化列表里；
- 构造函数函数体里常量成员已经初始化完毕，不可初始化；
- 特殊的常量数组成员初始化
2.3 静态常量成员
- 在定义的位置初始化
- 特别的静态常量数组成员需要constexpr关键字而非const
constexpr是C++11中新增的关键字，其语义是“常量表达式”，也就是在编译期可求值的表达式。最基础的常量表达式就是字面值或全局变量/函数的地址或sizeof等关键字返回的结果，而其它常量表达式都是由基础表达式通过各种确定的运算得到的。
3. 类对象初始化
class Test{
int a;
public:
Test():a(0){
cout <<"default"<<endl;
}
Test(const int &s):a(s){
cout <<"construct from int"<<endl;
}
Test(const Test &t):a(t.a){
cout <<"copy construction"<<endl;
}
Test& operator=(const Test &t){
a = t.a;
cout <<"operator="<<endl;
return *this;
}
};
int main() {
Test t1; //default
Test t2(2); //construct from int
Test t3(t2); //copy construction
Test t4 = t2; //copy construction
Test t5 = 5; //construct from int
t4 = t5; //operator=
Test t6[2]; //default default
Test t7[2] = {1,2};//construct from int construct from int
return 0;
}
- 类对象的成员利用构造函数列表初始化时，是按定义顺序初始化的
- 通过构造函数初始化．但是对所有类对象，类的静态变量只初始化一次，且数据只有一份．
- 类定义构造函数时必须定义默认构造函数，否则编译出错；默认构造函数，在声明 类的对象 数组或无参数类对象时会被调用；
定义类后编译器默认生成四个成员函数：默认构造函数、析构函数、拷贝构造函数、赋值函数
A(void); // 缺省的无参数构造函数
A(const A &a); // 缺省的拷贝构造函数
~A(void); // 缺省的析构函数
A & operate =(const A &a); // 缺省的赋值函数
