c++11 unkown总结

static_cast 类似于c中强制转型 也能把父类型强制转为子类型（不安全  指针不能访问子类型中的函数）在编译时检查

dynamic_cast 在运行时会检查 如果转换不合理 对于指针类型会返回NULL

class T{
public:
    virtual void t(){}
};
class B:public T{
public:
    void fun(){cout<<"OK"<<endl;}
};
int main()
{
    B *b = new B();
    T *t = new T();
    B *tmp = dynamic_cast<B*>(t);
    cout<<(void*)tmp;// 0x0
    return 0;
}

2.完美转发

函数转发问题:

在一个函数中A 中调用B（int& int&&  const int&  const int&&）

A的实参在传给B时会发生变化 这时候希望完美转发 即左值仍然是左值 右值仍然是右值

#include "stdafx.h"
#include <iostream>
 
using namespace std;
 
void fun(int &x) { cout << "lvalue ref" << endl; }
void fun(int &&x) { cout << "rvalue ref" << endl; }
void fun(const int &x) { cout << "const lvalue ref" << endl; }
void fun(const int &&x) { cout << "const rvalue ref" << endl; }
 
template<typename T>
void PerfectForward(T &&t) { fun(std::forward<T>(t)); }
 
int _tmain(int argc, _TCHAR* argv[])
{
	PerfectForward(10);           // rvalue ref
 
	int a;
	PerfectForward(a);            // lvalue ref
	PerfectForward(std::move(a)); // rvalue ref
 
	const int b = 8;
	PerfectForward(b);            // const lvalue ref
	PerfectForward(std::move(b)); // const rvalue ref
 
	system("pause");
	return 0;
}

调用Perfect 时  左值会自动转型为右值（这样fun就不知道本来是啥）通过forward完美转发时就保留了左右值的属性

 

3.异常处理机制

子程序中可以抛出异常throw 然后 找try catch 有没有捕获 如果没有则找调用该函数的函数 （栈展开） 同时释放局部对象（调用对象的析构函数）退出当前函数 如果都没有catch则一直到主函数  ！！所以析构函数不能抛出异常否则会导致资源的不完全释放

引申出来的：

异常安全： 在发生异常时不泄露资源 不破坏数据

（1） 不泄露资源

void Type::Func()
{
	Lock(&mutex);
	DoSomething();
	UnLock(&mutex);
}

在执行Do 抛出异常后不会执行Unlock 不好 这时可以用资源获取即初始化的方法 用一个静态对象管理锁  在抛出异常退出时调用析构函数释放锁

(2)不破坏数据

class Type
{
public:
	....
	Type& operator = (const Type &t)
	{
		if(this == &t)
			return *this;
		else
		{
			delete m_t;
			m_t = new T(t->m_t);
			return *this;
		}
	}
	....
	
private:
	T *m_t;
};

在new 分配时可能报bad_alloc异常 这时已经执行了delete 即在发生异常后 原始数据遭到破坏

可以采用copy and swap 先创建副本(在副本上进行操作) 不抛异常后再交换副本和原始数据

 

标签：11,PerfectForward,const,函数,int,void,c++,unkown,异常
来源： https://blog.csdn.net/futangxiang4793/article/details/100746540