标签：字符 har cti ber fail 表达 line cas 操作
数据类型 & 引用名 = 初始值(变量名)
const 类型 变量名
const int var = 10;
const 类型& 引用名
int var; const int & ref_var = var; //不能对ref_var进行修改
类名 const 对象名
#include<iostream> #include<string> using namespace std; const string str_obj = "qwq";//定义时初始化 以后不能修改
类名::函数名(形参表)const
class MyClass { public: MyClass() {}; ~MyClass() {}; int get_x(void)const;//只负责返回类x的值 并不修改成员的值 所以加const private: int x; }; int MyClass::get_x(void)const { return x; }
如果对成员写操作 编译时会报错,提高安全系;
类型 const 数组名[大小]
int const arr[10] = {1,2,3,4,5,6,7,8,9,10};
const 类型* 指针名
int const arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int const *p_int = arr;//指向数组arr //*p_int =10; //不能修改指针指向的值
类型* const 指针名
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int *const p_int = arr; *p_int = 10;//正确 p_int = arr;//错误 指向原来的也不对 不可修改
指针常量是指针本身是一个常量,指向地址不能修改(指向的单语言不一定是常量)
常量指针是不能修改指向内存地址的值
const int* p = &value; int * const q = &value;
这两个语句的含义是不同的，前者是"所指内容不可变"，后者则是"指向的地址不可变"
int def_var_1 = 20; void default_parameter_func(int num1 = def_var_1, int num2 = 3, char ch = ‘*‘);
inline
inline int max(int a, int b) { return a > b ? a : b; }
void display(); void display(const char*); void display(int one ,int two); void display(float number);
C语言
int b; float a = (float)b;
C++
int b; float a = float(b);//这种方式类似函数
+4
static_cast<new_type>(expr)
主要有以下用法：
（1）用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。
（2）用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
（3）把空指针转换成目标类型的空指针。
（4）把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉expression的const、volatile、或者__unaligned属性。
#include<iostream> #include <string> using namespace std; class Base {}; class Derived:public Base{}; int main() { float f = 12.3; float* pf = &f; int n = static_cast<int>(f); //ok n=12 //int* pn = static_cast<int*>(pf);//无法从float*转换为int* void* pv = static_cast<void*>(pf);//ok int* pn2 = static_cast<int*>(pv);//ok 但pn2无意义 Base * p_a = new Base; Derived * p_b = static_cast<Derived*>(p_a); Base o_a; Derived o_b; o_a = *p_b;//正确 隐式转换 子对象转换为父对象 o_a = static_cast<Derived>(*p_b);//正确 显示转换 o_b = *p_a;//错误 不存在父对象转换为子对象 o_b= static_cast<Derived>(*p_a);//错误 return 0; }
dynamic_cast <new_type> (expr)
把expr转换为newtype对象
将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理
即会作一定的判断。
对指针进行dynamic_cast，失败返回null，成功返回正常cast后的对象指针；
对引用进行dynamic_cast，失败抛出一个异常，成功返回正常cast后的对象引用。
注意：dynamic_cast在将父类cast到子类时，父类必须要有虚函数。例如在下面的代码中将CBasic类中的test函数不定义成
virtual时，编译器会报错：error C2683: dynamic_cast : “CBasic”不是多态类型
#include <iostream> using namespace std; class CBasic { public: virtual int test(){return 0;} // 一定要是 virtual }; class CDerived : public CBasic { public: virtual int test(){ return 1;} }; int main() { CBasic cBasic; CDerived cDerived; CBasic * pB1 = new CBasic; CBasic * pB2 = new CDerived; //dynamic cast failed, so pD1 is null. CDerived * pD1 = dynamic_cast<CDerived * > (pB1); //dynamic cast succeeded, so pD2 points to CDerived object CDerived * pD2 = dynamic_cast<CDerived * > (pB2); //dynamci cast failed, so throw an exception. // CDerived & rD1 = dynamic_cast<CDerived &> (*pB1); //dynamic cast succeeded, so rD2 references to CDerived object. CDerived & rD2 = dynamic_cast<CDerived &> (*pB2); return 0; }
const_cast <new_type> (expression)
const_cast转换符是用来移除变量的const或volatile限定符
const int constant = 21; const int* const_p = &constant; int* modifier = const_cast<int*>(const_p); *modifier = 7;
reinterpret_cast <new_type> (expression)
处理无关类型之间的转换.可以把一个指针转换为一个整数,也可以把一个整数转换为一个指针,还可以不同指针之间的转换
这也是一个很不安全的转换,只有转换为原始类型,彩色正确使用reinterpret_cast的方式
#include <iostream> // Returns a hash code based on an address unsigned short Hash( void *p ) { unsigned int val = reinterpret_cast<unsigned int>( p ); return ( unsigned short )( val ^ (val >> 16)); } using namespace std; int main() { int a[20]; for ( int i = 0; i < 20; i++ ) cout << Hash( a + i ) << endl; } //如果跟我一样是64位的系统，可能需要将unsigned int改成 unsigned long才能运行。
ostream
istream
cout.put(71).put(79).put(79).put(68).put(‘\n‘); //GOOD
cout.put(65+32)//字符a
标签：字符 har cti ber fail 表达 line cas 操作
原文地址：http://www.cnblogs.com/crosys/p/6363219.html
