数据类型、表达式 类型转换

数据类型与表达式

cout操纵符：hex，十六进制   oct八进制   dec十进制（默认）

进制表示：八进制以数字0为前缀；十六进制以0X或0x做前缀。（是数字0，不是字母o）

double型数字判断相等可以用 fabs(a-b)<1e-6

转义符：反斜线\  \a为响铃

一个语句太长可以分行写，行尾要用‘＼’（注意其后不能有空格）

注意区分逻辑运算符与关系运算符。

位运算符有　～　＜＜　＞＞　＆　＾　｜　六个。将数字转换为二进制后进行相应的按位操作。

可以连续赋值：a=b=c=1;

sizeof()用来判断一个类型或者变量所占内存的大小，单位为字节，byte。1 byte=8 bit

旧式强制类型转换：  （新类型）（表达式或变量）

用小括号赋初值。int a(3),b(4);。

逗号‘，’标记符可以将多个表达式组成为一个语句块，如用在for()中： for(a=2,b=3;a!=0;a--,b--){...}

int x=2,y=3,z=4;cout<<(x,y,z);//逗号表达式，取最后的语句作为结果  故输出4 

for 与 while

int main(int argc, char *argv[])
{
//	for(;;); 等同于 for(;;){}
//同理 while(i--){} 等同于 while(i--);
	//以下语句输出无穷个hi 
	for(;;){
		cout<<"hi";
	}
	//以下语句输出0个hi，死循环 
	for(;;);cout<<"hi";
	return 0;
}

 类型转换

1.1 reinpreter_cast<type-id> 

用法：reinpreter_cast<type-id> (expression)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。
这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。reinpreter_cast是特意用于底层的强制转型，导致实现依赖（就是说，不可移植）的结果。
int n=9;
// reinterpret_cast 仅仅是复制 n 的比特位到 d，因此d 包含无用值。
double d=reinterpret_cast<double & > (n);

1.2  const_cast

用法：const_cast<type_id> (expression)
用于修改类型的const或volatile属性。除了const 或volatile修饰之外，type_id和expression的类型是一样的，一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型，而C不提供消除const的机制（已验证）。

1.3 static_cast<>

在两个完全不相干的类之间进行转换，将会导致编译出错。

1.4 dynamic_cast<>

只用于对象的指针和引用，主要用于执行“安全的向下转型”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。

/*cast
有如下几个类和函数定义，选项中描述正确的是（多选）*/
#include 
    
    
     
     
using namespace std;

class A{
public:
    virtual void foo(){};
};
class B{
public:
    virtual void foo(){};
};
class C:public A,public B{
public:
    virtual void foo(){};
};
void bar1(A *pa){
    B*pc=dynamic_cast
     
     
      
      (pa);
}
void bar2(A *pa){
    B*pc=static_cast
      
      
       
       (pa);//error: invalid static_cast from type 'A*' to type 'B*'
}
void bar3(void ){
    C c;
    A*pa=&c;
    B*pc=static_cast
       
       
        
        (static_cast
        
        
          ( pa)); } /* A.bar1无法通过编译 B.bar2无法通过编译 C.bar3无法通过编译 D.bar1可以正确运行，但是采用了错误的cast方法。 B肯定选，D不确定。 */ 
        
       
       
      
      
     
     
    
    

#include 
     
     
      
      
using namespace std;

class CBasic
{
public:
     virtual int test(){return 0;}
};

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
      
      
       
        (pB1);   
                
//dynamic cast succeeded, so pD2 points to  CDerived object                                        
    CDerived * pD2 = dynamic_cast
       
       
        
         (pB2);   
    
//dynamci cast failed, so throw an exception.            
//    CDerived & rD1 = dynamic_cast
        
        
         
          (*pB1);   

//dynamic cast succeeded, so rD2 references to CDerived object.
    CDerived & rD2 = dynamic_cast
         
         
           (*pB2); getchar(); return 0; }