Resumo dos novos recursos do C ++ 11

Novos recursos no C ++ 11

A palavra-chave automática (C ++ 11) com base no intervalo para loop (C ++ 11) .O ponteiro nullptr (C ++ 11)
Gerenciamento de memória dinâmica em C ++
Array de contêiner serial forward_list;
Herança e polimorfismo: substituição final
delete: não gera a função de membro padrão
padrão: força o compilador a gerar funções-membro padrão
Ponteiros inteligentes: unique_ptr, shared_ptr, weak_ptr
Contêiner associativo estruturado em hash: série não ordenada

Inicialização unificada

O padrão no C ++ 98 permite o uso de chaves {} para definir um valor inicial uniforme da lista para elementos da matriz

int array1[] = {1,2,3,4,5};
int array2[5] = {0};

Isso não pode ser inicializado para contêineres vetoriais

vector<int> v{1,2,3,4,5};

Ele não pode ser compilado; portanto, toda vez que você define um vetor, é necessário definir o vetor primeiro e depois usar um loop para atribuir um valor inicial a ele, o que é muito inconveniente.
O C ++ 11 expande o escopo da lista entre colchetes (lista de inicialização) para disponibilizá-lo para todos os tipos internos e definidos pelo usuário Ao usar a lista de inicialização, você pode adicionar um sinal de igual (=) Não pode ser adicionado .

Inicialização de chaves embutidas do tipo {}

	// 内置类型变量
	int x1 = { 10 };
	int x2{ 10 };
	int x3 = 1 + 2;
	int x4 = { 1 + 2 };
	int x5{ 1 + 2 };
	int x6{ x1 + x2 };
	// 数组
	int arr1[5] {1, 2, 3, 4, 5};
	int arr2[]{1, 2, 3, 4, 5};
	// 动态数组，在C++98中不支持
	int* arr3 = new int[5]{1, 2, 3, 4, 5};
	// 标准容器
	vector<int> v{ 1, 2, 3, 4, 5 };
	map<int, int> m{ { 1, 1 }, { 2, 2, }, { 3, 3 }, { 4, 4 } };

Inicialização única lista de tipos personalizados

class Point
{
public:
	Point(int x = 0, int y = 0) 
		: _x(x), _y(y)
	{}
private:
	int _x;
	int _y;
};
int main()
{
	//两种初始化都可以
	Point p{ 1, 2 };
	Point p2(1, 2);
	return 0;
}

Inicialização de várias listas de tipos personalizados

Se você deseja dar suporte à inicialização da lista para vários objetos, é necessário adicionar um construtor com um parâmetro do tipo initializer_list à classe (classe de modelo) . Nota: initializer_list é um modelo de classe definido pelo sistema.Existem três métodos principais nesse modelo de classe: método begin (), end () iterador e size () para obter o número de elementos no intervalo.

template<class T>
	class vector
	{
	public:
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}
		vector(initializer_list<T>l)
			:_start(new T[l.size()])
		{
			_finish = _start;
			for (auto e : l)
			{
				*_finish++ = e;
			}
		}
	private:
		T* _start;
		T* _finish;
		T* _endofstorage;
	};

Dedução de tipo variável

derivação automática

resumo automático

dedução do tipo decltype

O pré-requisito para o uso de auto é: o tipo declarado por auto deve ser inicializado, caso contrário, o compilador não pode derivar o tipo real de auto

template<class T1,class T2>
//返回的时候，返回T1和T2都不行，应该返回T1+T2后的值的类型
auto Add(const T1& left, const T2& right)
{
	return left + right;
}

Se o tipo real do resultado após a adição puder ser usado como o tipo de retorno da função, não haverá erro, mas isso exige que o programa seja executado para saber o
tipo real do resultado , que é RTTI (Identificação do Tipo de Tempo de Execução).

typeidPode apenas visualizar o tipo e não definir o tipo com sua classe de resultados
dynamic_castSó pode ser usado em sistemas de herança que contêm funções virtuais

Portanto, novas palavras-chave são necessárias

decltype é o tipo usado para definir variáveis com base no tipo real da expressão , por exemplo: dedução do tipo de valor de retorno

//此处auto为占位符
//返回值类型追踪
auto  Add( T1& left,  T2& right)->decltype(left+right)
{
	return left + right;
	//ret = left + right;
}

int main()
{
	int a = 1;
	double b = 2.0;
	cout<< Add(a, b);
	return 0;
}

Faixa para loop

Intervalo para

substituição final

Resumido no polimorfismo

Ponteiro inteligente

Resumo do ponteiro inteligente

Nova matriz de array estático de contêineres, forward_list e série não ordenada

Delegar construtor

O chamado construtor de delegação: refere-se a um método de construção de classe no qual a função de delegação delega a tarefa construída ao construtor de destino.
O construtor que chama a "versão de referência" na lista de inicialização é chamado de construtor delegado e a chamada "versão de referência" é chamada de construtor de destino.
Nota: O construtor não pode "delegar" e usar a lista de inicialização ao mesmo tempo.

class Info {
public:
	Info() 
		: _type(0)
		, _name('a')
	{
		InitRSet();
	}
	Info(int type) 
		:Info()
		//不能再在初始化列表中初始化其它的成员变量
		//,_type(type)
	{
		//InitRSet();
		_type = type;
	}
	Info(char type) 
		:Info()
	{
		//InitRSet();
		_type = type;
	}
private:
	void InitRSet() 
	{
		//初始化其他变量
	}
private:
	int _type;
	char _name;
	//...
};

O construtor delegado também pode ser o construtor de destino
Lembre-se: a delegação de toque ainda pode ser compilada, mas transbordará na pilha certa

Referência de valor

Resumo das referências de rvalue

Controle de função padrão

O C ++ 11 permite que os programadores controlem se o compilador precisa gerar as funções geradas por padrão

Função padrão explícita

No C ++ 11, você pode adicionar = default à definição ou declaração da função padrão para instruir explicitamente o compilador a gerar a versão padrão da =defaultfunção.A função modificada é chamada de função padrão explícita .

class A
{
public:
	A(int a): _a(a)
	{}
	// 显式缺省构造函数，由编译器生成
	A() = default;
	// 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
	A& operator=(const A& a);
private:
	int _a;
};
	A& A::operator=(const A& a) = default;
int main()
{
	A a1(10);
	A a2;
	a2 = a1;
	return 0;
}

Excluir a função padrão

Se você deseja limitar a geração de determinadas funções padrão, no C ++ 98, a função é definida como privada e não definida, de modo que, se alguém quiser chamá-la, um erro será relatado. No C ++ 11, é mais simples: basta adicionar = delete à declaração da função.Esta sintaxe instrui o compilador a não gerar a versão padrão da função correspondente.A função modificada por = delete é chamada de função delete .

class A
{
public:
	A(int a): _a(a)
	{}
	// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
	A(const A&) = delete;
	A& operator(const A&) = delete;
private:
	int _a;
};
int main()
{
	A a1(10);
	// 编译失败，因为该类没有拷贝构造函数
	//A a2(a1);
	// 编译失败，因为该类没有赋值运算符重载
	A a3(20);
	a3 = a2;
	return 0;
}