1)请简述智能指针原理,并实现一个简单的智能指针

智能指针作用:管理别人的指针,主要特点:RAII(Resource Acquisition Is Initialization)资源分配即初始化,定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放。

注:对于编译器来说,智能指针实际上是一个栈对象,并非指针类型,在栈对象生命期即将结束时,智能指针通过析构函数释放有它管理的堆内存。所有智能指针都重载了“operator->”操作符,直接返回对象的引用,用以操作对象。访问智能指针原来的方法则使用“.”操作符。

访问智能指针包含的裸指针则可以用 get() 函数。由于智能指针是一个对象,所以if (my_smart_object)永远为真,要判断智能指针的裸指针是否为空,需要这样判断:if (my_smart_object.get())。

智能指针包含了 reset() 方法,如果不传递参数(或者传递 NULL),则智能指针会释放当前管理的内存。如果传递一个对象,则智能指针会释放当前对象,来管理新传入的对象。

所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放

智能指针包括

wKioL1ePEerAM3wqAAGAusKoFaU124.png

#include<iostream>
using namespace std;
template<class T>
class ScopePtr
{
	public:
		explicit ScopePtr(T* ptr)
		:_ptr(ptr)
		{}
		~ScopePtr()
		{
			delete _ptr;
		}
	private:
		ScopePtr(ScopePtr<T>& sp);
		ScopePtr& operator=(ScopePtr<T>& sp);
	protected:
		T* _ptr;
};
int main()
{
	char* p=new char[3];
	ScopePtr<char> s(p);
}
//AutoPtr
#include<iostream>
using namespace std;

template<class T>
class AutoPtr
{
	public:
		explicit AutoPtr(T* ptr)
		:_ptr(ptr)
		{}
		AutoPtr(AutoPtr<T>& ap)
		{
			_ptr=ap._ptr;
			ap._ptr=NULL;
		}
		AutoPtr& operator=(AutoPtr<T>& ap)
		{
			if(_ptr!=ap._ptr)
			{
				delete _ptr;
				_ptr=ap._ptr;
				ap._ptr=NULL;
			}
			return *this;
		}
		//重点,如果是数组,注意实现operator[]
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* GetStr()
		{
			return _ptr;
		}
		~AutoPtr()
		{
			delete _ptr;
		}
	protected:
		T* _ptr;
};
int main()
{
	int *a=new int[3];
	AutoPtr<int> p(a);
}

2)如何处理循环引用问题? 

a对象引用了b对象,b对象也引用了a对象,这种情况下a对象和b对象就形成了循环引用。

#include<iostream>
using namespace std;
template<class T>
struct ListNode
{
	T _data;
	ListNode<T>* _next;
	ListNode<T>* _prev;
};
void Test1()
{
	boost::shared_ptr<listNode<int>> cur=new ListNode<int>;
	boost::shared_ptr<listNode<int>> next=new ListNode<int>;
	cur->_next=next;
	next->_prev=cur;
	
	cout<<cu->use_count()<<endl;
	cout<<cur->use_count()<<endl; 
}

导致当出了作用域的时候,两个指针的引用计数都是1,故内存泄漏。析构函数:引用计数减减,直到为0才释放空间。

解决方法:将ListNode中的_next,_prev改为weak_ptr弱指针。支持weak_ptr<T>& operator=(shared_pt

r<T>& sp):没增加引用计数。

虽然释放next,但cur->_next成了野指针。不管weak_ptr所指是否有效,只负责shared_ptr赋值。

注:

引用计数是一种垃圾回收的形式,每一个对象都会有一个计数来记录有多少指向它的引用。其引用计数会变换如下面的场景

  • 当对象增加一个引用,比如赋值给变量,属性或者传入一个方法,引用计数执行加1运算。

  • 当对象减少一个引用,比如变量离开作用域,属性被赋值为另一个对象引用,属性所在的对象被回收或者之前传入参数的方法返回,引用计数执行减1操作。

  • 当引用计数变为0,代表该对象不被引用,可以标记成垃圾进行回收。

3)请实现一个单例模式的类,要求线程安全

单例模式就是说系统中对于某类的只能有一个对象,不可能出来第二个。


1.多线程安全单例模式实例一(不使用同步锁)

1 public class Singleton{
2     private static Singleton sin=new Singleton();    ///直接初始化一个实例对象
3     private Singleton(){    ///private类型的构造函数,保证其他类对象不能直接new一个该对象的实例
4     }
5     public static Singleton getSin(){    ///该类唯一的一个public方法    
6         return sin;
7     }
8 }

  上述代码中的一个缺点是该类加载的时候就会直接new 一个静态对象出来,当系统中这样的类较多时,会使得启动速度变慢 。现在流行的设计都是讲“延迟加载”,我们可以在第一次使用的时候才初始化第一个该类对象。所以这种适合在小系统。 


2.多线程安全单例模式实例二(使用同步方法)

 1 public class Singleton {  
 2      private static Singleton instance;  
 3      private Singleton (){ 
 4           
 5      }   
 6      public static synchronized Singleton getInstance(){    //对获取实例的方法进行同步 
 7        if (instance == null)     
 8          instance = new Singleton(); 
 9        return instance;
 10      }
 11  }

  上述代码中的一次锁住了一个方法, 这个粒度有点大 ,改进就是只锁住其中的new语句就OK。就是所谓的“双重锁”机制。

3.多线程安全单例模式实例三(使用双重同步锁)

 1 public class Singleton {  
 2      private static Singleton instance;  
 3      private Singleton (){ 
 4      }   
 5      public static Singleton getInstance(){    //对获取实例的方法进行同步    6        if (instance == null){ 
 7            synchronized(Singleton.class){ 
 8                if (instance == null) 
 9                    instance = new Singleton(); 
10            }
11        }
12        return instance;
13      }
14      
15  }

单例的目的是为了保证运行时Singleton类只有唯一的一个实例,最常用的地方比如拿到数据库的连接。

单例会带来什么问题?

我第一反映就是如果多个线程同时调用这个实例,会有线程安全的问题

  1. public class Singleton {  

  2.   

  3.   private static Singleton instance = new Singleton();  

  4.   

  5.   private Singleton() {}  

  6.   

  7.   public static Singleton getInstance() {  

  8.     return instance;  

  9.   }  

  10.   

  11. }  

 

这种方式没有使用同步,并且确保了调用static getInstance()方法时才创建Singleton的引用(static 的成员变量在一个类中只有一份)。


  1. public class ResourceFactory {     


    1. private class ResourceHolder {     

  2.         public static Resource resource = new Resource();     

  3.     }     

  4.     

  5.     public static Resource getResource() {     

  6.         return ResourceFactory.ResourceHolder.resource;     

  7.     }     

  8.     

  9.     static class Resource {     

  10.     }     

  11. }    

 上面的方式是值得借鉴的,在ResourceFactory中加入了一个私有静态内部类ResourceHolder ,对外提供的接口是 getResource()方法,也就是只有在ResourceFactory .getResource()的时候,Resource对象才会被创建,

这种写法的巧妙之处在于ResourceFactory 在使用的时候ResourceHolder 会被初始化,但是ResourceHolder 里面的resource并没有被创建,这里隐含了一个是static关键字的用法,使用static关键字修饰的变量只有在第一次使用的时候才会被初始化,而且一个类里面static的成员变量只会有一份,这样就保证了无论多少个线程同时访问,所拿到的Resource对象都是同一个。

4)如何定义一个只能在堆上生成对象的类? 

只能在堆内存上实例化的类:将析构函数定义为private,在栈上不能自动调用析构函数,只能手动调用。也可以将构造函数定义为private,但这样需要手动写一个函数实现对象的构造。

#include <iostream>
using namespace std;
 
//只能在堆内存上实例化的类
class CHeapOnly
{
public:
    CHeapOnly()
    {
        cout << "Constructor of CHeapOnly!" << endl;
    }
 
    void Destroy() const
    {
        delete this;
    }
 
private:
    ~CHeapOnly()
    {
        cout << "Destructor of CHeapOnly!" << endl;
    }
};


5)如何定义一个只能在栈上生成对象的类? 

只能在栈内存上实例化的类:将函数operator new和operator delete定义为private,这样使用new操作符创建对象时候,无法调用operator new,delete销毁对象也无法调用operator delete。

//只能在栈内存上实例化的类,就是不能使用new来构造类,把operator new私有化
class CStackOnly
{
public:
    CStackOnly()
    {
        cout << "Constructor of CStackOnly!" << endl;
    }
 
    ~CStackOnly()
    {
        cout << "Destrucotr of CStackOnly!" << endl;
    }
 
private:
    void* operator new(size_t size)
    {
    }
 
    void operator delete(void * ptr)
    {
    }
};


6)下列的结构体大小分别是多大(假设32位机器)?
struct A {
char a;
char b;
char c;
};//8

struct B {
int a;
char b;
short c;
};//16
struct C {
char b;
int a;
short c;
};//24内存对齐
#pragma pack(2)
struct D {
char b;
int a;
short c;
};//16
7)引用和指针有什么区别? 

 引用和指针的区别和联系:

  1. 引用只能在定义时初始化一次,之后不能改变指向其它变量(从一而终);指针变量的值可变。

  2. 引用必须指向有效的变量,指针可以为空。

  3. sizeof指针对象和引用对象的意义不一样。sizeof引用得到的是所指向的变量的大小,而sizeof指针是对象地址的大小。

  4. 指针和引用自增(++)自减(--)意义不一样。

  5. 相对而言,引用比指针更安全。

总结:

指针比引用更灵活,但是也更危险。使用指针时一定要注意检查指针是否为空。指针所指的地址释放以后最好置0,否则可能存在野指针问题。

8) const和define有什么区别? 

(1) 编译器处理方式不同

  define宏是在预处理阶段展开。

  const常量是编译运行阶段使用。

(2) 类型和安全检查不同

  define宏没有类型,不做任何类型检查,仅仅是展开。

  const常量有具体的类型,在编译阶段会执行类型检查。

(3) 存储方式不同

  define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。

  const常量会在内存中分配(可以是堆中也可以是栈中)。


(4)const 可以节省空间,避免不必要的内存分配。 例如:  
        #define PI 3.14159 //常量宏  
        const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......  
        double i=Pi; //此时为Pi分配内存,以后不再分配!  
        double I=PI; //编译期间进行宏替换,分配内存  
        double j=Pi; //没有内存分配  
        double J=PI; //再进行宏替换,又一次分配内存!  
const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而 #define定义的常量在内存中有若干个拷贝。 
(5) 提高了效率。 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高

宏的优点:

a.   const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应)。

b.  有些集成化的调试工具可以对const常量进行调试,但是不能对宏常量进行调试。

注:某些常量只在类中有效。由于#define定义的宏常量是全局的,不能达到目的,于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的,但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的,因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。

不能在类声明中初始化const数据成员。因为类的对象未被创建时。

const数据成员的初始化只能在类构造函数的初始化表中进行。

怎样才能建立在整个类中都恒定的常量呢?别指望const数据成员了,应该用类中的枚举常量来实现。例如

 class A

    {…

        enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量

        int array1[SIZE1];

        int array2[SIZE2];

    };

 枚举常量不会占用对象的存储空间,它们在编译时被全部求值。

枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数(如PI=3.14159)。sizeof(A) = 1200;其中枚举不占空间。

9) define和inline有什么区别? 

(1)#define 宏名要替换的代码    
宏定义,保存在预编译器的符号表中,执行高效;作为一种简单的符号替换,不进行其中参数有效性的检测

函数调用要有一定的时间和空间方面的开销,于是将影响其效率。而宏只是在预处理的地方把代码展开,不需要额外的空间和时间方面的开销,所以调用一个宏比调用一个函数更有效率。

  但是宏也有很多的不尽人意的地方。

1、.宏不能访问对象的私有成员。

2、.宏的定义很容易产生二意性。



(2)inline这个关键字的引入原因和const十分相似,inline 关键字用来定义一个类的内联函数,引入它的主要原因是用它替代C中表达式形式的宏定义。
表达式形式的宏定义一例:
   #define ExpressionName(Var1,Var2) (Var1+Var2)*(Var1-Var2)
    这种表达式形式宏形式与作用跟函数类似,但它使用预编译器,没有堆栈,使用上比函数高效。但它只是预编译器上符号表的简单替换,不能进行参数有效性检测及使用C++类的成员访问控制。
inline 推出的目的,也正是为了取代这种表达式形式的宏定义,它消除了它的缺点,同时又很好地继承了它的优点。inline代码放入预编译器符号表中,

高效;它是个真正的函数,调用时有严格的参数检测;它也可作为类的成员函数。

inline特点: 

  1. inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的的函数不适宜使用内联。

  2. inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉内联。

  3. inline必须函数定义放在一起,才能成为内联函数,仅将inline放在声明前是不起不作用的。

  4. 定义在类内的成员函数默认定义为内联函数。


2) 具体作用
直接在class类定义中定义各函数成员,系统将他们作为内联函数处理;成员函数是内联函数,意味着:每个对象都有该函数一份独立的拷贝。
在类外,如果使用关键字inline定义函数成员,则系统也会作为内联函数处理;

注:inline: 内联函数对编译器提出建议,是否进行宏替换,编译器有权拒绝

内联函数:

Tip: 只有当函数只有 10 行甚至更少时才将其定义为内联函数.

定义: 当函数被声明为内联函数之后, 编译器会将其内联展开, 而不是按通常的函数调用机制进行调用.
优点: 当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.
缺点: 滥用内联将导致程序变慢. 内联可能使目标代码量或增或减, 这取决于内联函数的大小. 内联非常短小的存取函数通常会减少代码大小, 但内联一个相当大的函数将戏剧性的增加代码大小. 现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。
结论: 一个较为合理的经验准则是, 不要内联超过 10 行的函数. 谨慎对待析构函数, 析构函数往往比其表面看起来要更长, 因为有隐含的成员和基类析构函数被调用!
另一个实用的经验准则: 内联那些包含循环或 switch 语句的函数常常是得不偿失 (除非在大多数情况下, 这些循环或 switch 语句从不被执行).
有些函数即使声明为内联的也不一定会被编译器内联, 这点很重要; 比如虚函数和递归函数就不会被正常内联. 通常, 递归函数不应该声明成内联函数.(递归调用堆栈的展开并不像循环那么简单, 比如递归层数在编译时可能是未知的, 大多数编译器都不支持内联递归函数). 虚函数内联的主要原因则是想把它的函数体放在类定义内, 为了图个方便, 抑或是当作文档描述其行为, 比如精短的存取函数


既为提出申请,不一定会成功。

宏和函数的区别:

wKiom1ePI***14VCAAHA1nWaMBY141.png

内联函数和宏的区别在于,宏是由预处理器对宏进行替代,而内联函数是通过编译器控制来实现的。而且内联函数是真正的函数,只是在需要用到的时候,内联函数像宏一样的展开,所以取消了函数的参数压栈,减少了调用的开销。你可以象调用函数一样来调用内联函数,而不必担心会产生于处理宏的一些问题。

10) malloc和new有什么区别?(十条) 

1.申请的内存所在位置

new操作符从自由存储区(free store)上为对象动态分配内存空间,而malloc函数从堆上动态分配内存。

自由存储区是C++基于new操作符的一个抽象概念,凡是通过new操作符进行内存申请,该内存即为自由存储区。而堆是操作系统中的术语,是操作系统所维护的一块特殊内存,用于程序的内存动态分配。自由存储区不仅可以是堆,还可以是静态存储区,这都看operator new在哪里为对象分配内存。

2.返回类型安全性

new操作符内存分配成功时,返回的是对象类型的指针,类型严格与对象匹配,无须进行类型转换,故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ,需要通过强制类型转换将void*指针转换成我们需要的类型。

类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图方法自己没被授权的内存区域。

3.内存分配失败时的返回值

new内存分配失败时,会抛出bac_alloc异常,它不会返回NULL;malloc分配内存失败时返回NULL。在使用C语言时,我们习惯在malloc分配内存后判断分配是否成功:


new根本不会返回NULL,而且程序能够执行到if语句已经说明内存分配成功了,如果失败早就抛异常了。正确的做法应该是使用异常机制。

4.是否需要指定内存大小

使用new操作符申请内存分配时无须指定内存块的大小,编译器会根据类型信息自行计算,而malloc则需要显式地指出所需内存的尺寸。

5.是否调用构造函数/析构函数

使用new操作符来分配对象内存时会经历三个步骤:

  • 第一步:调用operator new 函数(对于数组是operator new[])分配一块足够大的,原始的,未命名的内存空间以便存储特定类型的对象。

  • 第二步:编译器运行相应的构造函数以构造对象,并为其传入初值。

  • 第三部:对象构造完成后,返回一个指向该对象的指针。

使用delete操作符来释放对象内存时会经历两个步骤:

  • 第一步:调用对象的析构函数。

  • 第二步:编译器调用operator delete(或operator delete[])函数释放内存空间。

总之来说,new/delete会调用对象的构造函数/析构函数以完成对象的构造/析构。而malloc则不会。

6.对数组的处理

C++提供了new[]与delete[]来专门处理数组类型:

使用new[]分配的内存必须使用delete[]进行释放:new对数组的支持体现在它会分别调用构造函数函数初始化每一个数组元素,释放对象时为每个对象调用析构函数。注意delete[]要与new[]配套使用,不然会找出数组对象部分释放的现象,造成内存泄漏。

至于malloc,它并知道你在这块内存上要放的数组还是啥别的东西,反正它就给你一块原始的内存,在给你个内存的地址就完事。所以如果要动态分配一个数组的内存,还需要我们手动自定数组的大小:

7.new与malloc是否可以相互调用

operator new /operator delete的实现可以基于malloc,而malloc的实现不可以去调用new。

8.是否可以被重载

opeartor new /operator delete可以被重载。标准库是定义了operator new函数和operator delete函数的8个重载版本:

640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=

我们知道我们有足够的自由去重载operator new /operator delete ,以决定我们的new与delete如何为对象分配内存,如何回收对象。而malloc/free并不允许重载。

9.能够直观地重新分配内存

使用malloc分配的内存后,如果在使用过程中发现内存不足,可以使用realloc函数进行内存重新分配实现内存的扩充。realloc先判断当前的指针所指内存是否有足够的连续空间,如果有,原地扩大可分配的内存地址,并且返回原来的地址指针;如果空间不够,先按照新指定的大小分配空间,将原有数据从头到尾拷贝到新分配的内存区域,而后释放原来的内存区域。new没有这样直观的配套设施来扩充内存。

10.客户处理内存分配不足

在operator new抛出异常以反映一个未获得满足的需求之前,它会先调用一个用户指定的错误处理函数,这就是new-handler。new_handler是一个指针类型

640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=

指向了一个没有参数没有返回值的函数,即为错误处理函数。为了指定错误处理函数,客户需要调用set_new_handler,这是一个声明于的一个标准库函数:

640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=

set_new_handler的参数为new_handler指针,指向了operator new 无法分配足够内存时该调用的函数。其返回值也是个指针,指向set_new_handler被调用前正在执行(但马上就要发生替换)的那个new_handler函数。

对于malloc,客户并不能够去编程决定内存不足以分配时要干什么事,只能看着malloc返回NULL。

将上面所述的10点差别整理成表格:

640?wx_fmt=png&tp=webp&wxfrom=5&wx_lazy=

11) C++中static关键字作用有哪些? 

(1)设置变量的存储域,函数体内static变量的作用范围为该函数体,不同于auto变量,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值;
(2)限制变量的作用域,在模块内的static全局变量可以被模块内所用函数访问,但不能被模块外其它函数访问;
(3)限制函数的作用域,在模块内的static函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明它的模块内;
(4)在类中的static成员变量意味着它为该类的所有实例所共享,也就是说当某个类的实例修改了该静态成员变量,其修改值为该类的其它所有实例所见;
(5)在类中的static成员函数属于整个类所拥有,这个函数不接收this指针,因而只能访问类的static成员变量。

12) C++中const关键字作用有哪些?

(1)欲阻止一个变量被改变,可以使用const关键字。在定义该const变量时,通常需要对它进行初始化,因为以后就没有机会再去改变它了;
(2)对指针来说,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;
(3)在一个函数声明中,const可以修饰形参,表明它是一个输入参数,在函数内部不能改变其值;
(4)对于类的成员函数,若指定其为const类型,则表明其是一个常函数,不能修改类的成员变量;
(5)对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为“左值”。例如:
const classA operator*(const classA& a1,const classA& a2); 
  operator*的返回结果必须是一个const对象。如果不是,这样的变态代码也不会编译出错:
classA a, b, c;
(a * b) = c; // 对a*b的结果赋值 

注:

1) 关键字const的作用是为给读你代码的人传达非常有用的信息,实际上,声明一个参数为常量是为了告诉了用户这个参数的应用目的。

2) 通过给优化器一些附加的信息,使用关键字const也许能产生更紧凑的代码。

3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数,防止其被无意的代码修改。简而言之,这样可以减少bug的出现。

13) C++中包含哪几种强制类型转换?他们有什么区别和联系?


  • C++强制类型转换

static_cast/reinterpret_cast/const_cast/dynamic_cast

  • static_cast

static_cast用于非多态类型的转换(静态转换),任何标准转换都可以用它,但它不能用于两个不相关的类型进行转换。

注:static_cast 允许执行任意的隐式转换和相反转换动作。(即使它是不允许隐式的)
意思是说
它允许子类类型的指针转换为父类类型的指针(这是一个有效的隐式转换),同时,也能够执行相反动作:转换父类为它的子类。除了操作类型指针,也能用于执行类型定义的显式的转换,以及基础类型之间的标准转换:

  • reinterpret_cast

reinterpret_cast操作符用于将一种类型转换为另一种不同的类型

特点:(这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。如果情况是从一个指针到整型的拷贝,内容的解释是系统相关的,所以任何的实现都不是方便的。一个转换到足够大的整型能够包含它的指针是能够转换回有效的指针的。)

  • const_cast

const_cast最常用的用途就是删除变量的const属性,方便赋值。

  • dynamic_cast

dynamic_cast用于将一个父类对象的指针转换为子类对象的指针或引用(动态转换)

向上转型:子类对象指针->父类指针/引用(不需要转换)

向下转型:父类对象指针->子类指针/引用(用dynamic_cast转型是安全的)

  1. dynamic_cast只能用于含有虚函数的类

  2. dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0

不过,与static_cast不同,在后一种情况里(注:即隐式转换的相反过程),dynamic_cast会检查操作是否有效。也就是说,它会检查转换是否会返回一个被请求的有效的完整对象。
检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针,返回值为NULL.

总结: C++的四种强制转型形式每一种适用于特定的目的: 
  ·dynamic_cast 主要用于执行“安全的向下转型(safe downcasting)”,也就是说,要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型,也是唯一可能有重大运行时代价的强制转型。
    ·static_cast 可以被用于强制隐型转换(例如,non-const 对象转型为 const 对象,int 转型为 double,等等),它还可以用于很多这样的转换的反向转换(例如,void* 指针转型为有类型指针,基类指针转型为派生类指针),但是它不能将一个 const 对象转型为 non-const 对象(只有 const_cast 能做到),它最接近于C-style的转换。
  ·const_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型。 
  ·reinterpret_cast 是特意用于底层的强制转型,导致实现依赖(implementation-dependent)(就是说,不可移植)的结果,例如,将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。