[学习][记录] c++语言：从放弃到入门

c++11 新关键字以及引入的新特性

nullptr

nullptr 是用于解决 NULL 和 0 的有疑义关系的。NULL 通常被义为(void*)0。在 如下应用中会引发歧义。

入参

#include <iostream> 
using namespace std; 

void f(int){} 
void f(bool){} 
void f(void*){} 
int main() {
 f(0); // 调用f(int)
 f(NULL); // 可能无法编译通过，但一般会调用f(int)
 f(nullptr); // 调用f(void*)
}

解释：

1. C++ 视 0 首先为 int 型，因此，调用 f(0) 即调用 f(int)
2. NULL 的情况复杂些，C++ 首先视其为广义整型。假如 NULL 被定义为普通 的 0，则调用 f(int)； 如果 NULL 被定义成 0L，则 long -> int, long -> bool, 0L -> void*, 这三 种情况都是合法的，此时，编译器会报错
3. 使用 nullptr，则不会有重载函数调用模糊的问题 - nullptr 不属于广义整型，也不是普通意义上的指针。 - nullptr 的实际类型是 std::nullptr_t，它能够隐式的转换成所有的原始指针 类型，故可将其视为一个可指向所有类型的指针。

办法

避免NULL重载编译报错:

f((int)NULL) 通过强转的办法解决

返值

使用 0 与 result 作比较，则一时不能确定 findRecord 的返回值类型 (可能是 广义整型，也可能是指针类型); 使用 nullptr，可以清楚地知道 findRecord 的返回值， 必定是一个指针类型。

auto result = findRecord( /* arguments */ );
 if (result == 0) { ... }
 
auto result = findRecord( /* arguments */ ); 
if (result == nullptr) { ... }

override

含义

覆盖重新写从父类继承过来的函数
覆写父类的虚函数时候，好的 IDE 一定会给出斜体等的提示，表示此函数覆写自 父类。

目的

避免发生，编译通过，但是逻辑错误的情况 例如函数名写错了 但是编译通过，却不是从父类继承过来的函数。
利用关键字 override 则指明，此种覆写关系，若此关系不成立，则以报错的形式提示 给用户。

问题?

class G{
public:
	virtual void func(int) {
		printf("G::func(int) \n");
	};

};

class H:G{
public:
	//virtual void func(int) override{
	//	printf("H::func(int) \n");
	//}

	virtual void func(double){
		printf("H::func(double) \n");
	}
};

void main() {
	H *p = new H; 
	p->func(5); 
	p->func(5.0); 

	system("pause");
}

vs2015
输出
H::func(double)
H::func(double)
请按任意键继续. . .

疑问？？？
没调用到G类的func(int)

final

含义

关键字 final 有两个用途:

第一，它阻止了子类继承；

class A final 
{
public: 
	virtual void func() const; 
};

class B: A //错误 编译报错 A is final
{
public: 
	void func() const override final;//  错误 编译报错 A is final
{
};

第二，阻止一个虚函数的覆 写。

class A 
{
public: 
	virtual void func() const; 
};

class B
{
public: 
	void func() const override final;//OK 
};

class C: B {
public:
	void func() const; //error, B::func is final  编译报错
};

意义

阻止类的无限扩展。

=default =delete

default

C++ 的类有四类特殊成员函数，它们分别是：
1.默认构造函数
2.析构函数
3.拷贝构造函数
4.拷贝赋值运算符。

class A {
public:
 	A();//构造函数 创建类的实例时 调用
 	~A();//析构函数 销毁类的实例时 调用
 	A(const A &) =;//拷贝构造函数 类实例之间的拷贝 例如A　a;A b = a;//此时调用拷贝构造函数
 	A operator=(const A &);//拷贝赋值运算符   本质重载运算符=进行初始化
}

关键字default
如果程序员没有显式地为一个类定义某个特殊成员函数，而又需要用到该特殊成员 函数时，则编译器会隐式的为这个类生成一个默认的特殊成员函数。

class A {
public: A() = default; 
A(int x ):_x(x) {} 
private: int _x; 
};

delete

为了能够让程序员显式的禁用某个函数，C++11 标准引入了一个新特性： "=delete"函数。程序员只需在函数声明后上“=delete;”，就可将该函数禁用。

class Singleton {
public:
 static Singleton* getInstance() {
  if(_ins == nullptr) 
  _ins = new Singleton; 
  return _ins; 
 }
 Singleton(Singleton &) = delete; 
 Singleton& operator=(Singleton &) = delete; 
private: 
 Singleton(){
 } 
 static Singleton* _ins; 
};

Singleton* Singleton::_ins = nullptr; //类的静态变量在类外初始化

int main() { 
 Singleton *ps = Singleton::getInstance(); 
 Singleton ps(*ps); 
 *ps = Singleton::getInstance(); 
 return 0; 
}

Raw String Literals

缘由

C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要 原生义的时候，需要反转义，比较麻烦。

使用

C++提供了 R"()"，原生字符串，即字符串中无转义，亦无需再反义。但是注意() 中的)"会导至提前结束。

#include <iostream> 

using namespace std;

string path = "C:\Program Files (x86)\alipay\aliedit\5.1.0.3754"; // 错误，\没转义
string path2= "C:\\Program Files (x86)\\alipay\\aliedit\\5.1.0.3754"; //正确，\转义了 用\\或者/，但麻烦
string path3= R"(C:\Program Files (x86)\alipay\aliedit\5.1.0.3754)"; //正确，使用了R()
string path4= R"(C:\Program "Files" (x86)\\alipay\aliedit\5.1.0.3754)";//正确，使用了R()

//string path5= R"(C:\Program "Files" (x86)\\alipay\aliedit\)"5.1.0.3754)";//错误，R()的缺陷

int main(int argc, char *argv[]) {
	cout << path.c_str() << endl;
	cout << path2.c_str() << endl;
	cout << path3.c_str() << endl;
	cout << path4.c_str() << endl;
	system("pause");
	return 0; 
}



输出结果：
C:Program Files (x86)lipayliedit.1.0.3754
C:\Program Files (x86)\alipay\aliedit\5.1.0.3754
C:\Program Files (x86)\alipay\aliedit\5.1.0.3754
C:\Program "Files" (x86)\\alipay\aliedit\5.1.0.3754

Range-Based for 循环Foreach

一种基于STL容器遍历的一种for循环形式 类似Java的 foreach

语法形式：

for (declaration : expression) 
      statement

例如
vector<int> vecInt = {0,1,2,3,4,5}; //expression 列表
for(auto &i:vecInt){//auto &i  is declaration 申明
	cout << i << endl; 
}

等价写法1
vector<int> vecInt = { 1,2,3,4,5 };
for (int i = 0; i<vecInt.size(); i++) {
	int tmp = vecInt.at(i);
	cout << tmp << endl;
}

等价写法2
vector<int> vecInt = { 1,2,3,4,5 };
vector<int>::iterator itr = vecInt.begin();
for (; itr != vecInt.end(); itr++) {
	cout << *itr << endl;
}

解释：

expression 部分是一个对象，必须是一个序列，比方说
用花括号括起来的初始值
1.列表
2.数组
int[] a={1,2,3,4,5}; char ch[] = “123”;string str = “china”;
3.vector 或 string 等类型的对象。
vector vet = {1,2,3};list list= {1,2,3} map<int,string>map = {1,“123”};
这些类型的共同特点是拥有能返回迭 代器的 begin 和 end 成员。

declaration 部分负责定义一个变量，该变量将被用于访问序列中的基础元素。
每 次迭代，declaration 部分的变量会被初始化为 expression 部分的下一个元素值。
确 保类型相容最简单的办法是使用 auto 类型说明符。

initialization list {} STL初始化

normal init 常规初始化

所谓的常规初始化，即调用类的构 造器。

vector

vector<int> vi; 
vector<int> vi(10,10);//size 10,each value 10
vector<int> vi(arr,arr+10);//begin,end

list

list<int> li(10);
list<int> li2(10);

list<int> li3(10,1);//size 10,each value 1

int arr2[10] = {};
list<int> li4(arr2,arr2+10);//begin,end

map

//map[key] = value
map<int,string> mis; 
mis[0] = "first"; 
mis[1] = "second"; 
mis[2] = "third"; 


//make_pair
map<int,string> mis2(mis.begin(),mis.end());
mis.insert(std::make_pair(3, "fourth"));
mis.insert(pair<int, string>(3, "fourth"));

//value_type
mis.insert(map<int, string>::value_type(3, "fourth")); 
for (auto& pair : mis) 
	cout << pair.first << ":" << pair.second.c_str() << endl;

initialization List {} 列表方式初始化

以初始化列表的方式来进行实始化，打破了，原有的初始化格局，令实始化更直观 化，人性化。

vector<int> vi = {1,2,3,4,5}; 
list<int> li = {1,2,3,4,5}; 
map<int,string> mis = { 
	{1,"c"}, {2,"c++"}, 
	{3,"java"},{4,"scala"},
	{5,"python"}
	};
	
mis.insert({6,"ruby"}); 

for(auto &is: mis) {
 cout<<is.first<<is.second<<endl; 
}

未完待续