现代C++ — 稳定性和兼容性

目录

1、原始字面量

2、long long 整形

3、类成员的快速初始化 

4、final 和 override

final

override

5、模板的优化

模板的右尖括号

 默认模板参数

6、数值类型和字符串之间的转换

 数值转换为字符串

字符串转换为数值

7、静态断言 static_assert

8、noexcept

异常

 异常接口声明

noexcept

---

最近在学习大丙老师的C++11，将学习过程中的自己觉得重要的点记录一下吧。

原链接

1、原始字面量

        在 C++11 中添加了定义原始字符串的字面量，定义方式为：R “xxx(原始字符串)xxx” 其中（）两边的字符串可以省略。

        原始字面量 R 可以直接表示字符串的实际含义，而不需要额外对字符串做转义或连接等操作。

        比如：编程过程中，使用的字符串中常带有一些特殊字符，对于这些字符往往要做专门的处理，使用了原始字面量就可以轻松的解决这个问题了，比如打印路径：

#include
#include
using namespace std;
int main()
{
    string str = "D:\hello\world\test.text"; // 路径间隔符'\'是转移字符
    cout << str << endl;
    string str1 = "D:\\hello\\world\\test.text";    //需要对 '\'进行转义，得到一个没有特殊含义的'\'
    cout << str1 << endl;
    string str2 = R"(D:\hello\world\test.text)";//原始字面量不用做任何处理
    cout << str2 << endl;

    return 0;
}

2、long long 整形

        C++11 标准要求 long long 整型可以在不同平台上有不同的长度，但至少有64位(8字节)。long long 整型有两种:

long long num1 = 123456789LL; //使用 LL 后缀
long long num2 = 123456789ll; //使用 ll后缀

// unsigned long long类型
unsigned long long num1 = 123456789ULL;
unsigned long long num2 = 123456789ull;
unsigned long long num3 = 123456789uLL;
unsigned long long num4 = 123456789Ull;

---

对于有符号类型的 long long 和以下三种类型等价：

1. long long int
2. signed long long
3. signed long long int

 对于无符号类型long long 和以下两种类型等价：

1. unsigned long long
2. unsigned long long int

---

在中，与 long long 整 型相关的宏一共有 3 个：

1. LLONG_MIN - 最小的 long long 值
2. LLONG_MAX - 最大的 long long 值
3. ULLONG MAX - 最大的 unsigned long long 值

3、类成员的快速初始化 

        在进行类成员变量初始化的时候，C++11 标准对于 C++98 做了补充，允许在定义类的时候在类内部直接对非静态成员变量进行初始化，在初始化的时候可以使用等号 = 也可以 使用花括号 {} 

class Test
{
public:
    Test():a(10),b(20),c(30) //通过初始化列表指定的值会覆盖就地初始化时指定的值。
    {
    }
private:
    int a = 9; //就地初始化
    int b = {5};
    int c{12};
    double array[4] = { 3.14, 3.15, 3.16, 3.17};
    double array1[4] { 3.14, 3.15, 3.16, 3.17 };
    string s1("hello");     // error，不能使用小括号 () 初始化对象
    string s2{ "hello, world" };
};

4、final 和 override

final

C++ 中增加了 final 关键字来限制某个类不能被继承，或者某个虚函数不能被重写（阻止子类重写父类的这个函数），和 Jave 的 final 关键字的功能是类似的。如果使用 final 修饰函数，只能修饰虚函数，并且要把final关键字放到类或者函数的后面。

final修饰函数要把关键字放在函数后面： 

class Base
{
public:
    virtual void test()
    {
        cout << "Base class...";
    }
};

class Child : public Base
{
public:
    void test() final
    {
        cout << "Child class...";
    }
};

class GrandChild : public Child
{
public:
    // 语法错误, 不允许重写。孙子类中对这个方法就只有使用的份了，不能重写。
    /*
    void test()
    {
        cout << "GrandChild class...";
    }
    */
    
    
};

final修饰类，要把关键字放在类名后面： 

class Base
{
public:
    virtual void test()
    {
        cout << "Base class...";
    }
};

//Child 类是被 final 修饰过的，因此 Child 类不允许有派生类
class Child final: public Base
{
public:
    void test()
    {
        cout << "Child class...";
    }
};

// error, 语法错误
class GrandChild : public Child
{
public:
};

override

override 关键字 确保 在 派生类中声明的重写函数 与基类的虚函数有相同的签名（同名、同参数、同返回值），如果签名不一样会报错。同时也明确表明将会重写基类的虚函数，这样就可以保证重写的虚函数的正确性，也提高了代码的可读性，和 final 一样这个关键字要写到方法的后面。使用方法如下：

class Base
{
public:
    virtual void test()
    {
        cout << "Base class...";
    }
};

class Child : public Base
{
public:
    void test() override  //这个关键字要写到方法的后面
    {
        cout << "Child class...";
    }
};

class GrandChild : public Child
{
public:
    void test() override
    {
        cout << "Child class...";
    }
};

5、模板的优化

模板的右尖括号

        在泛型编程中，模板实例化有一个非常繁琐的地方，那就是连续的两个右尖括号（>>）会被编译器解析成右移操作符，而不是模板参数表的结束。

         C++11改进了编译器的解析规则，尽可能地将多个右尖括号（>）解析成模板参数结束符，方便我们编写模板相关的代码。

// test.cpp
#include 
#include 
using namespace std;

template 
class Base
{
public:
    void traversal(T& t)
    {
        auto it = t.begin();
        for (; it != t.end(); ++it)
        {
            cout << *it << " ";
        }
        cout << endl;
    }
};


int main()
{
    vector v{ 1,2,3,4,5,6,7,8,9 };
    Base> b; //连续的 >>
    b.traversal(v);

    return 0;
}

使用C++11进行编译： g++ test.cpp -std=c++11 -o app

 默认模板参数

在 C++98/03 标准中，类模板可以有默认的模板参数

#include 
using namespace std;

template 
class Test
{
public:
    void print()
    {
        cout << "current value: " << t << endl;
    }
};

int main()
{
    Test<> t;
    t.print();

    Test t1;
    t1.print();

    return 0;
}

但是不支持函数的默认模板参数，在C++11中添加了对函数模板默认参数的支持:

#include 
using namespace std;

template 	// C++98/03不支持这种写法, C++11中支持这种写法
void func(T t)
{
    cout << "current value: " << t << endl;
}

int main()
{
    func(100);
    return 0;
}

---

        通过上面的例子可以得到如下结论：当所有模板参数都有默认参数时，函数模板的调用如同一个普通函数。但对于类模板而言，哪怕所有参数都有默认参数，在使用时也必须在模板名后跟随 <> 来实例化。

         另外：函数模板的默认模板参数在使用规则上和其他的默认参数也有一些不同，它没有必须写在参数表最后的限制。

#include 
#include 
using namespace std;

template 
R func(N arg)
{
    return arg;
}

int main()
{
    //函数返回值类型使用了默认的模板参数(int)，函数的参数类型(N)是自动推导出来的为 int 类型。
    auto ret1 = func(520);
    cout << "return value-1: " << ret1 << endl;
    
    //函数的返回值指定为 double 类型，函数参数是通过实参推导出来的，为 double 类型
    auto ret2 = func(52.134);
    cout << "return value-2: " << ret2 << endl;

    auto ret3 = func(52.134);
    cout << "return value-3: " << ret3 << endl;
    
    /函数的参数为指定为 int 类型，函数返回值指定为 char 类型，不需要推导
    auto ret4 = func(100);
    cout << "return value-4: " << ret4 << endl;

    return 0;
}

当默认模板参数和模板参数自动推导同时使用时（优先级从高到低）：

1. 如果可以推导出参数类型则使用推导出的类型
2. 如果函数模板无法推导出参数类型，那么编译器会使用默认模板参数
3. 如果无法推导出模板参数类型并且没有设置默认模板参数，编译器就会报错。

6、数值类型和字符串之间的转换

 数值转换为字符串

使用 to_string() 方法可以非常方便地将各种数值类型转换为字符串类型，这是一个重载函，函数声明位于头文件 中，函数原型如下：

// 头文件 
string to_string (int val);
string to_string (long val);
string to_string (long long val);
string to_string (unsigned val);
string to_string (unsigned long val);
string to_string (unsigned long long val);
string to_string (float val);
string to_string (double val);
string to_string (long double val);

字符串转换为数值

// 定义于头文件 


int       stoi( const std::string& str, std::size_t* pos = 0, int base = 10 );
long      stol( const std::string& str, std::size_t* pos = 0, int base = 10 );
long long stoll( const std::string& str, std::size_t* pos = 0, int base = 10 );

unsigned long      stoul( const std::string& str, std::size_t* pos = 0, int base = 10 );
unsigned long long stoull( const std::string& str, std::size_t* pos = 0, int base = 10 );

float       stof( const std::string& str, std::size_t* pos = 0 );
double      stod( const std::string& str, std::size_t* pos = 0 );
long double stold( const std::string& str, std::size_t* pos = 0 );

1. str：要转换的字符串
2. pos：传出参数，记录从哪个字符开始无法继续进行解析，比如: 123abc, 传出的位置为 3
3. base：若 base 为 0 ，则自动检测数值进制：若前缀为 0 ，则为八进制，若前缀为 0x 或 0X，则为十六进制，否则为十进制。

1. 如果字符串中所有字符都是数值类型，整个字符串会被转换为对应的数值，并通过返回值返回
2. 如果字符串的前半部分字符是数值类型，后半部不是，那么前半部分会被转换为对应的数值，并通过返回值返回
3. 如果字符第一个字符不是数值类型转换失败

7、静态断言 static_assert

        我们以前使用的 assert 是一个运行时断言，也就是说它只有在程序运行时才能起作用 。这意味着不运行程序我们将无法得知某些条件是否是成立的。

        C++11 提供的静态断言 static_assert。所谓静态就是在编译时就能够进行检查的断言，使用时不需要引用头文件。静态断言的另一个好处是，可以自定义违反断言时的错误提示信息。

         

// assert.cpp
#include                                          
using namespace std;
  
int main()
{
    static_assert(sizeof(long) == 4, "错误, 不是32位平台...");
    cout << "64bit Linux 指针大小: " << sizeof(char*) << endl;
    cout << "64bit Linux long 大小: " << sizeof(long) <

由于静态断言的表达式是在编译阶段进行检测，所以在它的表达式中不能出现变量，也就是说这个表达式必须是常量表达式。

8、noexcept

异常

         异常通常用于处理逻辑上可能发生的错误，在 C++98 中为我们提供了一套完善的异常处理机制，我们可以直接在程序中将各种类型的异常抛出，从而强制终止程序的运行。

 

int main()
{ 
    try
    {
        throw -1; 
    } 
    catch (int e)
    { 
        cout << "int exception, value: " << e << endl; 
    } 
    cout << "That's ok!" << endl; 
    return 0; 
}

异常被抛出后，从进入 try 块起，到异常被抛掷前，这期间在栈上构造的所有对象，都会被自动析构。析构的顺序与构造的顺序相反。这一过程称为栈的解旋。

 异常接口声明

为了加强程序的可读性，可以在函数声明中列出可能抛出的所有异常类型，常用的有如下三种书写方式：

struct MyException
{
    MyException(string s) :msg(s) {}
    string msg;
};

// divisionMethod 函数后添加了 throw 异常接口声明，
// 其参数表示可以抛出的异常类型，分别为 int 和 MyException 类型。

//如果没有添加异常接口声明，表示在该函数中可以抛出任意类型的异常。
double divisionMethod(int a, int b) throw(MyException, int)
{
    if (b == 0)
    {
        throw MyException("division by zero!!!");
        // throw 100;
    }
    return a / b;
}

//throw 异常接口声明，其参数列表为空，表示该函数不允许抛出异常。
double divisionMethod2(int a, int b) throw()
{
    if (b == 0)
    {
        cout << "division by zero!!!" << endl;
    }
    return a / b;
}


int main()
{
    try
    {	
        double v = divisionMethod(100, 0);
        cout << "value: " << v << endl;
    }
    catch (int e)
    {
        cout << "catch except: "  << e << endl;
    }
    catch (MyException e)
    {
        cout << "catch except: " << e.msg << endl;
    }
    return 0;
}

noexcept

        表示函数不会抛出异常的动态异常声明 throw()  被新的 noexcept 异常声明所取代。

        noexcept 形如其名， 表示其修饰的函数不会抛出异常 。

        不过与 throw () 动态异常声明不同的是，在 C++11 中如果 noexcept 修饰的函数抛出了异常，编译器可以选择直接调用 std::terminate () 函数来终止程序的运行。

        这比基于异常机制的 throw () 在效率上会高一些`。这是因为异常机制会带来一些额外开销，比如函数抛出异常，会导致函数栈被依次地展开（栈解旋），并自动调用析构函数释放栈上的所有对象。

 

double divisionMethod(int a, int b) noexcept
{
    if (b == 0)
    {
        cout << "division by zero!!!" << endl;
        return -1;
    }
    return a / b;
}

noexcept还可以接受一个常量表达式作为参数：

double divisionMethod(int a, int b) noexcept(常量表达式);

常量表达式的结果会被转换成一个 bool 类型的值：

1. 值为 true，表示函数不会抛出异常
2. 值为 false，表示这里有可能抛出异常
3. 不带常量表达式的 noexcept 相当于声明了 noexcept（true），即不会抛出异常。