C++总结

一、 const限定符

1. 定义一种变量，它的值不能够被改变。（任何试图为这个值赋值的行为都会一引发错误）。

const int i=24;
1

一般来说，如果你认定变量是一个常量表达式，那就把它声明为constexpr类型。

constexpr int i=24;
1

2.const 的变量可以初始化不是const的变量。

    //下面情况都是正确的
    
    const int j = 10;
	int i = j;
	cout <<"const初始化no_const类型变量：" << i << endl;

	int k = 10;
	const int v = k;

	cout <<"no_const类型变量初始化const变量：" << k << endl;
1
2
3
4
5
6
7
8
9
10

3.常量引用，不允许修改值

	int i=0;
	const int& r2=i; //r2是常量引用，不允许r2修改i的值

1
2
3

4.指针常量与常量指针

	int i=0;
	//指针常量，不允许修改指针的指向，但可以通过p修改i的值
	int* const p=&i;
	//常量指针，允许修改指针的指向，但是不允许通过pj修改i的值
	const int* pj=&i;
	//不允许修改指针的指向，不允许通过pi修改i的值。
	const int* const pi=&i;
1
2
3
4
5
6
7

5.函数中的const

//可以读取i，但是不能够修改i的值
//可以传入const int 也可以传入 int
void fun(const int i)
{

}
//这个函数会和上面的函数重复定义。
void fun(int i)
{
}

1
2
3
4
5
6
7
8
9
10
11

const T 对象可以用T或者const T 对象初始化。
而 T对象只能通过 T对象初始化。

//fun1（）为成员函数
void fun1( int i) const
{
}

1
2
3
4
5

• 函数后面加上const表示成员函数隐含传入的this指针为const指针，决定了在该函数中，任意修改它所在的数据成员的操作是不允许的。(唯一例外是对于mutable修饰的数据成员)。
• 加了const的成员函数可被非const对象和const对象调用。
• 不加const的成员函数只能被非const的对象调用。

二、extern

• 如果想在多个文件之间共享对象，必须在变量的定义之间添加extern关键字。

extern double pi=3.1415926;
1

三、explicit

• 作用：在C++中。explicit关键字是用来修饰类的构造函数的，被修饰的构造函数的类不能发生相应的隐式类型的转换，只能以显示的方式进行类型转换。

class Test {
private :
	int x;
	double y;
public:
	Test(int xx):x(xx),y(0.0){}
	Test(double yy):x(1),y(yy){}
};
class Test1 {
private:
	int x;
	double y;
public:
	explicit Test1(int xx) :x(xx), y(0.0) {}
	explicit  Test1(double yy) :x(1), y(yy) {}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

只能通过显示的转换。

四、类型转换

1. static_cast< typename>(val)
   适合任何具有明确定义的类型转换，只要不包含底层const，都可以。

	int x = 10;
	double j = static_cast<double>(x);
1
2

3. const_cast< typename>(val)
   只改变运算对象的底层const

	const char* pc;
	char* p=const_cast<char*>(pc);
	
	//下面代码是错误的，不能修改基础类型
	char p = 'a';
	char* pi = const_cast<char*>(p);
1
2
3
4
5
6

5. dynamic_cast< typename>(val)
   用于将基类的指针或引用安全的转化成派生类的指针和引用。