C++11语言扩展：常规特性

最新推荐文章于 2023-03-29 11:40:29 发布
最新推荐文章于 2023-03-29 11:40:29 发布
阅读量1.6k 收藏
点赞数

From：http://blog.jobbole.com/55063/

本节内容：auto、decltype、基于范围的for语句、初始化列表、统一初始化语法和语义、右值引用和移动语义、Lambdas、noexcept防止抛出异常、constexpr、nullptr——一个指针空值常量、复制并再抛出异常、内联命名空间、用户自定义数据标识。

auto

推导

1
auto x = 7;

在这里因为它的初始化类型我们将得到x的int类型。一般来说，我们可以写

1
auto x = expression;

x的类型我们将会根据初始化表达式“ expression”的类型来自动推导。

当一个变量的类型很难准确的知道或者写出的时候，用atuo通过初始化表达式的类型进行推导显然是非常有用的。

参考：

1
2
3
4
5
template < class T> void printall( const vector<T>& v)
{
     for (auto p = v.begin(); p!=v.end(); ++p)
         cout << *p << "\n" ;
}

在C++98里我们必须这样写

1
2
3
4
5
template < class T> void printall( const vector<T>& v)
    {
        for ( typename vector<T>::const_iterator p = v.begin(); p!=v.end(); ++p)
            cout << *p << "\n" ;
    }

当一个变量的类型取决于模板实参的时候不用auto真的很难定义，例如：

1
2
3
4
5
6
template < class T, class U> void multiply( const vector<T>& vt, const vector<U>& vu)
     {
         // ...
         auto tmp = vt[i]*vu[i];
         // ...
     }

 

从T*U的表达式，我们人类的思维是很难理清tmp的类型的，但是编译器肯定知道T和U经过了什么特殊处理。

auto的特性在最早提出和应用时是有区别的：1984年初，Stroustrup在他的Cfront实现里用到了它，但是是由于C的兼容问题被迫拿来用的，这些兼容的问题已经在C++98和C++99接受了隐性int时候消失了。也就是说，现在这两种语言要求每一个变量和函数都要有一个明确的类型定义。auto旧的含义（即这是一个局部变量）现在是违法的。标准委员会的成员们在数百万行代码中仅仅只找到几百个用到auto关键字的地方，并且大多数出现在测试代码中，有的甚至就是一个bug。

auto在代码中主要是作为简化工具，并不会影响标准库规范。

参考：

decltype

decltype(E)的类型(“声明类型”)可用名称或表达E来声明。例如：

1
2
3
4
5
6
7
8
9
void f( const vector< int >& a, vector< float >& b)
   {
       typedef decltype(a[0]*b[0]) Tmp;
       for ( int i=0; i<b.size(); ++i) {
           Tmp* p = new Tmp(a[i]*b[i]);
           // ...
       }
       // ...
   }

这个概念已经流行在泛型编程的标签“typeof”很长一段时间,但实际使用的“领域”的实现是不完整和不兼容,所以标准版命名了decltype。

注意:喜欢使用auto时,你只是需要一个变量的类型初始化。你真的需要decltype如果你需要一个类型的东西不是一个变量,例如返回类型。

参考：

  • the C++ draft 7.1.6.2 Simple type specifiers
  • [Str02] Bjarne Stroustrup. Draft proposal for “typeof”. C++ reflector message c++std-ext-5364, October 2002. (original suggestion).
  • [N1478=03-0061] Jaakko Jarvi, Bjarne Stroustrup, Douglas Gregor, and Jeremy Siek: Decltype and auto (original proposal).
  • [N2343=07-0203] Jaakko Jarvi, Bjarne Stroustrup, and Gabriel Dos Reis: Decltype (revision 7): proposed wording.

基于范围的for循环

声明的范围像是STL-sequence定义的begin()和end()，允许你在这个范围内循环迭代。所有标准容器可以作为一个范围来使用，比如可以是std::string,初始化器列表,一个数组,和任何你可以定义begin()和end()的，比如istream。例如：

1
2
3
4
5
void f(vector< double >& v)
{
     for (auto x : v) cout << x << '\n' ;
     for (auto& x : v) ++x;  // using a reference to allow us to change the value
}

你可以看到，V中所有的元素都从begin()开始迭代循环到了end()。另一个例子:

1
for ( const auto x : { 1,2,3,5,8,13,21,34 }) cout << x << '\n' ;

begin()(和end())可以被做为x.begin()的成员或一个独立的函数被称为开始(x)。成员版本优先。

参考：

初始化列表

推导

1
2
3
4
5
6
7
8
9
vector< double > v = { 1, 2, 3.456, 99.99 };
    list<pair<string,string>> languages = {
        { "Nygaard" , "Simula" }, { "Richards" , "BCPL" }, { "Ritchie" , "C" }
    };
    map<vector<string>,vector< int >> years = {
        { { "Maurice" , "Vincent" , "Wilkes" },{1913, 1945, 1951, 1967, 2000} },
        { { "Martin" , "Ritchards" }, {1982, 2003, 2007} },
        { { "David" , "John" , "Wheeler" }, {1927, 1947, 1951, 2004} }
    };

初始化列表不再只针对于数组了。定义一个接受｛｝初始化列表的函数（通常是初始化函数）接受一个std::initializer_list < T >的参数类型，例如：

1
2
3
4
5
6
void f(initializer_list< int >);
f({1,2});
f({23,345,4567,56789});
f({});  // the empty list
f{1,2}; // error: function call ( ) missing
years.insert({{ "Bjarne" , "Stroustrup" },{1950, 1975, 1985}});

初始化器列表可以是任意长度的,但必须同种类型的(所有元素必须的模板参数类型,T,或可转换T)。

一个容器可能实现一个初始化列表构造函数如下：

1
2
3
4
5
6
7
8
9
10
template < class E> class vector {
   public :
       vector (std::initializer_list<E> s) // initializer-list constructor
       {
               reserve(s.size());  // get the right amount of space
               uninitialized_copy(s.begin(), s.end(), elem);   // initialize elements (in elem[0:s.size()))
           sz = s.size();  // set vector size
       }
       // ... as before ...
   };

直接初始化和复制初始化的区别是对初始化列表的维护，但是因为初始化列表的相关联的频率就降低了。例如std::vector有一个int类型显示构造函数和initializer_list构造函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
vector< double > v1(7);   // ok: v1 has 7 elements
    v1 = 9;                 // error: no conversion from int to vector
    vector< double > v2 = 9;  // error: no conversion from int to vector
    void f( const vector< double >&);
    f(9);                           // error: no conversion from int to vector
    vector< double > v1{7};           // ok: v1 has 1 element (with its value 7.0)
    v1 = {9};                       // ok v1 now has 1 element (with its value 9.0)
    vector< double > v2 = {9};        // ok: v2 has 1 element (with its value 9.0)
    f({9});                         // ok: f is called with the list { 9 }
    vector<vector< double >> vs = {
        vector< double >(10),         // ok: explicit construction (10 elements)
        vector< double >{10},         // ok explicit construction (1 element with the value 10.0)
        10                          // error: vector's constructor is explicit
    };

函数可以作为一个不可变的序列访问initializer_list。例如：

1
2
3
4
void f(initializer_list< int > args)
     {
         for (auto p=args.begin(); p!=args.end(); ++p) cout << *p << "\n" ;
     }

仅具有一个std::initializer_list的单参数构造函数被称为初始化列表构造函数。

标准库容器，string类型及正则表达式均具有初始化列表构造函数，以及（初始化列表）赋值函数等。一个初始化列表可被用作Range，例如，表达式Range。

初始化列表是一致泛化初始化解决方案的一部分。他们还防止类型收窄。一般来说,你应该通常更喜欢使用{ }来代替()初始化,除非你想用c++98编译器来分享代码或(很少)需要使用()调用没initializer_list重载构造函数。

参考：

统一初始化语法和语义

c++ 98提供了几种方法初始化一个对象根据其类型和初始环境。滥用时,会产生可以令人惊讶的错误和模糊的错误消息。推导：

1
2
3
4
string a[] = { "foo" , " bar" };          // ok: initialize array variable
   vector<string> v = { "foo" , " bar" };    // error: initializer list for non-aggregate vector
   void f(string a[]);
   f( { "foo" , " bar" } );                  // syntax error: block as argument

和

1
2
3
4
int a = 2;              // "assignment style"
int aa[] = { 2, 3 };    // assignment style with list
complex z(1,2);         // "functional style" initialization
x = Ptr(y);             // "functional style" for conversion/cast/construction

和

1
2
3
int a(1);   // variable definition
   int b();    // function declaration
   int b(foo); // variable definition or function declaration

要记得初始化的规则并选择最好的方法去初始化是比较难的。

C++11的解决方法是允许所有的初始化使用初始化列表

1
2
3
4
5
6
7
8
9
10
11
X x1 = X{1,2};
  X x2 = {1,2};   // the = is optional
  X x3{1,2};
  X* p = new X{1,2};
  struct D : X {
      D( int x, int y) :X{x,y} { /* ... */ };
  };
  struct S {
      int a[3];
      S( int x, int y, int z) :a{x,y,z} { /* ... */ }; // solution to old problem
  };

重点是，x{a}在在执行代码中都创建了一个相同的值，所以在使用“｛｝”进行初始化合法的情况下都产生了相同的结果。例如：

1
2
3
4
5
X x{a};
  X* p = new X{a};
  z = X{a};         // use as cast
  f({a});           // function argument (of type X)
  return {a};       // function return value (function returning X)

参考：

右值引用和移动语义

左值（用在复制操作符左边）和右值（用在复制操作符右边）的区别可以追溯到Christopher Strachey （C++遥远的祖先语言ＣＰＬ和外延语义之父）的时代。在C++中，非const引用可以绑定到左值，const引用既可以绑定到左值也可以绑定要右值。但是右值却不可以被非const绑定。这是为了防止人们改变那些被赋予新值之前就被销毁的临时变量。例如：

1
2
3
4
void incr( int & a) { ++a; }
     int i = 0;
     incr(i);    // i becomes 1
     incr(0);    // error: 0 in not an lvalue

如果incr（0）被允许，那么就会产生一个无法被人看到的临时变量被执行增加操作，或者更糟的0会变成1.后者听起来很傻，但实际上确实存在这样一个bug在Fortran编译器中：为值为0的内存位置分配。

到目前为止还好，但考虑以下代码：

1
2
3
4
5
6
template < class T> swap(T& a, T& b)      // "old style swap"
    {
        T tmp(a);   // now we have two copies of a
        a = b;      // now we have two copies of b
        b = tmp;    // now we have two copies of tmp (aka a)
    }

如果T是一个复制元素要付出昂贵代价的类型，比如string和vector，swap将会变成一个十分昂贵的操作（对于标准库来说，我们有专门化的string和vector来处理）。注意一下这些奇怪的现象：我们并不想任何变量拷贝。我们仅仅是想移动变量a,b和tmp的值。

在C++11中，我们可以定义“移动构造函数”和“移动赋值操作符”来移动，而不是复制他们的参数：

1
2
3
4
5
6
7
8
template < class T> class vector {
     // ...
     vector( const vector&);          // copy constructor
     vector(vector&&);           // move constructor
     vector& operator=( const vector&);   // copy assignment
     vector& operator=(vector&&);        // move assignment
};  // note: move constructor and move assignment takes non-const &&
     // they can, and usually do, write to their argument

& &表明“右值引用”。一个右值引用可以绑定到一个右值(而不是一个左值)：

1
2
3
4
5
6
X a;
   X f();
   X& r1 = a;      // bind r1 to a (an lvalue)
   X& r2 = f();        // error: f() is an rvalue; can't bind
   X&& rr1 = f();  // fine: bind rr1 to temporary
   X&& rr2 = a;    // error: bind a is an lvalue

赋值这个操作的背后思想，并不是拷贝，它只是构造一个源对象的代表然后再替换。例如，string s1 = s2的移动，它不是产生s2的拷贝，而是让s1把s2中字符变为自己的同时删除自己原有的字符串（也可以放在s2中，但是它也面临着被销毁）

我们如何知道是否可以简单的从源对象进行移动？我们可以告诉编译器：

1
2
3
4
5
6
7
template < class T>
void swap(T& a, T& b)   // "perfect swap" (almost)
{
     T tmp = move(a);    // could invalidate a
     a = move(b);        // could invalidate b
     b = move(tmp);      // could invalidate tmp
}

move(x)只是意味着你“你可以把x当作一个右值”,

如果把move()称做eval()也许会更好，但是现在move()已经用了好多年了。在c++11中，move()模板（参考简介）和右值引用都可以使用。

右值引用也可以用来提供完美的转发。

在C++0x的标准库中，所有的容器都提供了移动构造函数和移动赋值操作符，那些插入新元素的操作，如insert()和push_back(), 也都有了可以接受右值引用的版本。最终结果是，在无用户干预时，标准容器和算法的性能都提升了，因为复制操作的减少。

参考：

lambdas

Lambda表达式是一种描述函数对象的机制，它的主要应用是描述某些具有简单行为的函数（译注：Lambda表达式也可以称为匿名函数，具有复杂行为的函数可以采用命名函数对象，当然,简单和复杂之间的划分依赖于编程人员的选择）。例如：

1
2
3
4
5
6
vector< int > v = {50, -10, 20, -30};
std::sort(v.begin(), v.end());  // the default sort
// now v should be { -30, -10, 20, 50 }
// sort by absolute value:
std::sort(v.begin(), v.end(), []( int a, int b) { return abs (a)< abs (b); });
// now v should be { -10, 20, -30, 50 }

参数 [&](int a, int b) { return abs(a) < abs(b); }是一个"lambda"(又称为"lambda函数"或者"lambda表达式"), 它描述了这样一个函数操作：接受两个整形参数a和b，然后返回对它们的绝对值进行"<"比较的结果。（译注：为了保持与代码的一致性，此处应当为"[] (int a, int b) { return abs(a) < abs(b); }"，而且在这个lambda表达式内实际上未用到局部变量，所以 [&] 是无必要的）

一个Lambda表达式可以存取在它被调用的作用域内的局部变量。例如：

1
2
3
4
5
6
7
8
9
void f(vector<Record>& v)
    {
        vector< int > indices(v.size());
        int count = 0;
        generate(indices.begin(),indices.end(),[&count](){ return count++; });
        // sort indices in the order determined by the name field of the records:
        std::sort(indices.begin(), indices.end(), [&]( int a, int b) { return v[a].name<v[b].name; });
        // ...
    }

有人认为这“相当简洁”，也有人认为这是一种可能产生危险且晦涩的代码的方式。我的看法是，两者都正确。

[&] 是一个“捕捉列表(capture list)”，用于描述将要被lambda函数以引用传参方式使用的局部变量。如果我们仅想“捕捉"参数v，则可以写为: [&v]。而如果我们想以传值方式使用参数v，则可以写为：[=v]。如果什么都不捕捉，则为：[]。将所有的变量以引用传递方式使用时采用 [&], [=] 则相应地表示以传值方式使用所有变量（译注：“所有变量”即指lambda表达式在被调用处，所能见到的所有局部变量）。

如果某一函数的行为既不通用也不简单，那么我建议采用命名函数对象或者函数。例如，如上示例可重写为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void f(vector<Record>& v)
    {
        vector< int > indices(v.size());
        int count = 0;
        generate(indices.begin(),indices.end(),[&](){ return ++count; });
        struct Cmp_names {
            const vector<Record>& vr;
            Cmp_names( const vector<Record>& r) :vr(r) { }
            bool operator()( int a, int b) const { return vr[a].name<vr[b].name; }
        };
        // sort indices in the order determined by the name field of the records:
        std::sort(indices.begin(), indices.end(), Cmp_names(v));
        // ...
    }

对于简单的函数功能，比如记录名称域的比较，采用函数对象就略显冗长，尽管它与lambda表达式生成的代码是一致的。在C++98中，这样的函数对象在被用作模板参数时必须是非本地的（译注：即你不能在函数对象中像此处的lambda表达式那样使用被调用处的局部变量），然而在C++中（译注：意指C++0x），这不再是必须的。

为了描述一个lambda，你必须提供：

  • 它的捕捉列表：它可以使用的变量列表（除了形参之外），如果存在的话（"[&]" 在上面的记录比较例子中意味着“所有的局部变量都将按照引用的方式进行传递”）。如果不需要捕捉任何变量，则使用 []。
  • （可选的）它的所有参数及其类型（例如： (int a, int b) ）。
  • 组织成一个块的函数行为（例如：{ return v[a].name < v[b].name; }）。
  • （可选的）采用了新的后缀返回类型符号的返回类型。但典型情况下，我们仅从return语句中去推断返回类型，如果没有返回任何值，则推断为void。

参考：

noexcept防止抛出异常

如果一个函数不能抛出异常或者一个程序没有对函数抛出的异常进行处理，那么这个函数可以用关键字noexcept进行修饰，例如：

1
2
3
4
5
6
7
extern "C" double sqrt ( double ) noexcept;    // will never throw
    vector< double > my_computation( const vector< double >& v) noexcept // I'm not prepared to handle memory exhaustion
    {
        vector< double > res(v.size());   // might throw
        for ( int i; i<v.size(); ++i) res[i] = sqrt (v[i]);
        return res;
    }

如果一个被noexcept修饰的函数抛出了异常（所以异常会跳出呗noexcept修饰的函数），程序会调用std::terminate()这个函数来终止程序。在对象被明确定义的状态下不能调用terminate()；比如无法保证析构函数正常调用，不能保证栈的自动释放，也无法保证在遇到任何问题时重新启动。故意这样的使noexcept成为一种简单“粗暴”而有效的处理机制-它比旧的处理机制throw()动态抛出异常要有效的多。

它可以让一个函数根据条件来实现noexcept修饰。比如，一个算法可以根据他的模板参数来决定自己是否抛出异常。

1
2
3
4
5
6
template < class T>
    void do_f(vector<T>& v) noexcept(noexcept(f(v.at(0)))) // can throw if f(v.at(0)) can
    {
        for ( int i; i<v.size(); ++i)
            v.at(i) = f(v.at(i));
    }

这里，第一个noexcept被用作操作符operator：如果if f(v.at(0))不能够抛出异常，noexcept(f(v.at(0)))则返回true，所以f()和at()是无法抛出异常noexcept。

noexcept()操作符是一个常量表达式，并且不计算表达式的值。

声明的通常形式是noexcept(expression)，并且单独的一个“noexcept”关键字实际上就是的一个noexcept(true)的简化。一个函数的所有声明都必须与noexcept声明保持 兼容。

一个析构函数不应该抛出异常；通常，如果一个类的所有成员都拥有noexcept修饰的析构函数，那么这个类的析构函数就自动地隐式地noexcept声明，而与函数体内的代码没有关系。

通常，将某个抛出的异常进行移动操作是一个很坏的主意，所以，在任何可能的地方都用noexcept进行声明。如果某个类的所有成员都有使用noexcept声明的析构函数，那么这个类默认生成的复制或者移动操作（类的复制构造函数，移动构造函数等）都是隐式的noexcept声明。（？）

noexcept 被广泛地系统地应用在C++11的标准库中，以此来提供标准库的性能和满足标准库对于简洁性的需求。

参考：

constexpr

常量表达式机制：

  • 提供了更多的通用的值不发生变化的表达式
  • 允许用户自定义的类型成为常量表达式
  • 提供了一种保证在编译期完成初始化的方法

考虑下面这段代码：

1
2
3
4
5
6
7
8
9
10
11
enum Flags { good=0, fail=1, bad=2, eof=4 };
constexpr int operator|(Flags f1, Flags f2) { return Flags( int (f1)| int (f2)); }
void f(Flags x)
{
     switch (x) {
     case bad:         /* ... */ break ;
     case eof:         /* ... */ break ;
     case bad|eof:     /* ... */ break ;
     default :          /* ... */ break ;
     }
}

在这里，常量表达式关键字constexpr表示这个重载的操作符“|”就应该像一个简单的表单一样，如果它的参数本身就是常量 ，那么这个操作符应该在编译时期就应该计算出它的结果来。
除了可以在编译时期被动地计算表达式的值之外，我们希望能够主动地要求表达式在编译时期计算其结果值，从而用作其它用途，比如对某个变量进行赋值。当我们在变量声明前加上constexpr关键字之后，可以实现这一功能，当然，它也同时会让这个变量成为常量。

1
2
3
4
5
6
constexpr int x1 = bad|eof; // ok
    void f(Flags f3)
    {
        constexpr int x2 = bad|f3;  // error: can't evaluate at compile time
        int x3 = bad|f3;        // ok
    }

通常，我们希望编译时期计算可以保护全局或者名字空间内的对象，对名字空间内的对象，我们希望它保存在只读空间内。
对于那些构造函数比较简单，可以成为常量表达式（也就是可以使用constexpr进行修饰）的对象可以做到这一点(?)

1
2
3
4
5
6
7
8
struct Point {
       int x,y;
       constexpr Point( int xx, int yy) : x(xx), y(yy) { }
   };
   constexpr Point origo(0,0);
   constexpr int z = origo.x;
   constexpr Point a[] = {Point(0,0), Point(1,1), Point(2,2) };
   constexpr int x = a[1].x;   // x becomes 1
  •  const的主要功能是修饰一个对象而不是通过一个接口（即使对象很容易通过其他接口修改）。只不过声明一个对象常量为编译器提供了优化的机会。特别是，如果一个声明了一个对象常量而他的地址没有取到，编译器通常可以在编译时对他进行初始化（尽管这不是肯定的）保证这个对象在他的列表里而不是把它添加到生成代码里。
  • constexpr的主要功能可以在编译时计算表达式的值进行了范围扩展，这是一种计算安全而且可以用在编译时期（如初始化枚举或者整体模板参数）。constexpr声明对象可以在初始化编译的时候计算出结果来。他们基本上只保存在编译器的列表，如果需要的话会释放到生成的代码里。

参考：

nullptr 一个指针空值常量

nullptr是一个指针空值常量，不是一个整数。

1
2
3
4
5
6
7
8
9
10
char * p = nullptr;
  int * q = nullptr;
  char * p2 = 0;           // 0 still works and p==p2
  void f( int );
  void f( char *);
  f(0);                   // call f(int)
  f(nullptr);             // call f(char*)
  void g( int );
  g(nullptr);             // error: nullptr is not an int
  int i = nullptr;        // error: nullptr is not an int

参考：

复制并再抛出异常

你如何捕获一个异常然后把它抛出到另一个线程？使用标准文档18.8.5里描述的标准库的魔力方法吧。

exception_ptr current_exception(); 正在处理的异常（15.3）或者正在处理的异常的副本（拷贝）将返回一个exception_ptr 变量，如果当前没有遇到异常，返回值为一个空的exception_ptr变量。只要exception_ptr指向一个异常，那么至少在exception_ptr的生存期内，运行时能够保证被指向的异常是有效的。

void rethrow_exception(exception_ptr p);
template exception_ptr copy_exception(E e); 它的作用如同：

1
2
3
4
5
try {
        throw e;
    } catch (...) {
        return current_exception();
    }

当我们需要将异常从一个线程传递到另外一个线程时，这个方法十分有用的。

内联命名空间

内联命名空间机制是通过一种支持版本更新的机制来支持库的演化，推导：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// file V99.h:
    inline namespace V99 {
        void f( int );    // does something better than the V98 version
        void f( double ); // new feature
        // ...
    }
    // file V98.h:
    namespace V98 {
        void f( int );    // does something
        // ...
    }
    // file Mine.h:
    namespace Mine {
    #include "V99.h"
    #include "V98.h"
    }

我们这里有一个命名空间Mine包含最新版本的（V99）和前一个版本(V98),如果你想要显式应用（某个版本的函数），你可以：

1
2
3
4
5
6
#include "Mine.h"
    using namespace Mine;
    // ...
    V98::f(1);  // old version
    V99::f(1);  // new version
    f(1);       // default version

内联的关键是使内联命名空间的声明和直接在外围命名空间声明一样。

lnline是静态的及面向实现的设施，它由命名空间的设计者放置来帮助用户进行选择。对于Mine的用是不可以说“我想要的命名空间是V98而不是V99”。

参照：

  • Standard 7.3.1 Namespace definition [7]-[9].

用户自定义数据标识

C++提供了很多内置的数据标识符（2.14节变量）

built-in types (2.14 Literals):

1
2
3
4
5
6
7
123 // int
   1.2 // double
   1.2F    // float
   'a' // char
   1ULL    // unsigned long long
   0xD0    // hexadecimal unsigned
   "as"    // string

然而，爱C++98里并没有用户自定义的数据标识符。这就有悖于甚至冲突“用户自定义类型和内置leiixng一样得到支持”的原则。特殊情况下，人们有这样的需求：

1
2
3
4
5
6
7
"Hi!" s          // std::string, not ``zero-terminated array of char''
    1.2i            // imaginary
    123.4567891234df    // decimal floating point (IBM)
    101010111000101b    // binary
    123s            // seconds
    123.56km        // not miles! (units)
    1234567890123456789012345678901234567890x   // extended-precision

C++11支持“用户自定义数据标识”通过在变量名后面加一个后缀来标定所需类型，例如：

1
2
3
4
5
6
7
8
constexpr complex< double > operator "" i( long double d)  // imaginary literal
     {
         return {0,d};   // complex is a literal type
     }
     std::string operator "" s ( const char * p, size_t n)   // std::string literal
     {
         return string(p,n); // requires free store allocation
     }

注意constexpr的使用可以在编译时期计算。有了这个功能，我们可以这样写：

1
2
3
4
5
template < class T> void f( const T&);
f( "Hello" ); // pass pointer to char*
f( "Hello" s);    // pass (5-character) string object
f( "Hello\n" s);  // pass (6-character) string object
auto z = 2+1i;  // complex(2,1)

基本（实现）方法是编译器在解析什么语句代表一个变量之后，再分析一下后缀。用户自定义数据标识机制只是简简单单的允许用户制定一个新的后缀，并决定如何对它之前的数据进行处理。要想重新定义一个内建的数据标识的意义或者它的参数、语法是不可能的。一个数据标识操作符可以使用它（前面）的数据标识传递过来的处理过的值（如果是使用新的没有定义过的后缀的值）或者没有处理过的值（作为一个字符串）。
要得到一个没有处理过的字符串，只要使用一个单独的const char*参数即可，例如：

1
2
3
4
5
6
Bignum operator "" x( const char * p)
   {
       return Bignum(p);
   }
   void f(Bignum);
   f(1234567890123456789012345678901234567890x);

这个C语言风格的字符串"1234567890123456789012345678901234567890"被传递给了操作符 operator"" x()。注意，我们并没有明确地把数字转换成字符串。

有以下四种数据标识的情况，可以被用户定义后缀来使用用户自定义数据标识：

  • 整型标识：允许传入一个unsigned long long或者const char*参数
  • 浮点型标识：允许传入一个long double或者const char*参数
  • 字符串标识：允许传入一组(const char*,size_t)参数
  • 字符标识：允许传入一个char参数。

注意，你为字符串标识定义的标识操作符不能只带有一个const char*参数（而没有大小）。例如：

1
2
string operator "" S( const char * p);     // warning: this will not work as expected
    "one two" S; // error: no applicable literal operator

根本原因是如果我们想有一个“不同的字符串”，我们同时也想知道字符的个数。后缀可能比较短（例如，s是字符串的后缀，i是虚数的后缀，m是米的后缀，x是扩展类型的后缀），所以不同的用法很容易产生冲突，我们可以使用namespace（命名空间）来避免这些名字冲突：

1
2
3
4
5
6
7
8
namespace Numerics {
       // ...
       class Bignum { /* ... */ };
       namespace literals {
           operator "" X( char const *);
       }
   }
   using namespace Numerics::literals;

参考：


战斗鸡排
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于牛顿迭代法和PQ分解法实现电力系统常规潮流计算，算例数据基于美国西部9节点系统(WSCC9).zip
03-12
6. **集成能力**：MATLAB可以与其他编程语言（如C、C++、Java、Python等）及外部应用程序进行数据交换和联合开发，也可以调用硬件接口进行实时实验和控制。 7. **交互式工作空间**：用户可以在命令窗口中直接输入...
C++ (11) 语言扩展
王 杰的专栏
01-15 881
本节内容：auto、decltype、基于范围的for语句、初始化列表、统一初始化语法和语义、右值引用和移动语义、Lambdas、noexcept防止抛出异常、constexpr、nullptr——一个指针空值常量、复制并再抛出异常、内联命名空间、用户自定义数据标识。 auto 推导 1 auto x = 7; 在这里因为它
for(auto x:v)中的x是什么东西？
weixin_35756624的博客
01-16 353
在 C++ 中，for (auto x: v) 中的 x 是 v 中的元素的一个副本。auto 关键字用于自动推断 x 的类型。v 可以是一个数组或一个容器(例如 vector、list 等)。在循环中，x 会依次被赋值为 v 中的每一个元素。 ...
关于cout 输出 char 型字符 ++ch和 ch+1 不同的结果（直接看详解）
坚持才能放假的博客
03-18 2564
一、简述 今天在做练习题时注意到了之前所没有注意到的问题： 若给同样的 ch ，cout << ++ch; 与 cout << ch+1; 输出后的结果不一样。 浅思之后明白了，其实这个现象解释起来不难，细心一点就能够解释。 二、代码 #include<iostream> using namespace std; int main() { char ch; cin.get(ch); //cin.get()读取缓冲区中第一个字符 //此时读取的字符不是
C语言操作
HPUZJH
07-01 254
引用操作 #include<iostream> using namespace std; void test1(int x){ x = 1024; cout<<x<<endl; } void test2(int & x){ x = 1024; cout<<x<<endl; } void swap(int & a,int & b){ int t = a; a = b; b = t; } int main().
C++17之noexcept作为类型的一部分
janeqi1987的专栏
09-01 1341
在c++ 17异常处理规范成为函数类型的一部分。也就是说，下面两个函数现在有两种不同的类型: void f1(); void f2() noexcept; // different type 在c++ 17之前，这两个函数都具有相同的类型。 因此，编译器现在将检测如果你使用一个函数抛出异常，而一个函数不抛出任何异常的情况: void (*fp)() noexcept; // pointe...
SqlServer系统数据库的作用深入了解
01-21
Master Master数据库保存有放在SQLSERVER实体上的所有数据库，它还是将引擎固定起来的粘合...这些过程一般都用像C++这样的现代编程语言。 如果不幸碰到系统崩溃而必须恢复主数据库的情况，你可以参看MCSE／MCDBA Steven
Java编程思想(完整版)
02-13
由于C++是C的一个超集，所以包含的许多特性都是后者不具备的，这些特性使C++在某些地方显得过于复杂。 Java语言首先便假定了我们只希望进行面向对象的程序设计。也就是说，正式用它设计之前，必须先将自己的思想转入...
网管教程 从入门到精通软件篇.txt
04-25
ASM：汇编语言源文件，Pro/E装配文件 ASP：动态网页文件；ProComm Plus安装与连接脚本文件；Astound介绍文件 AST：Astound多媒体文件；ClarisWorks“助手”文件 Axx：ARJ压缩文件的分包序号文件，用于将一个大...
MySQL 5.1官方简体中文参考手册
07-02
10.1. 常规字符集和校对 10.2. MySQL中的字符集和校对 10.3. 确定默认字符集和校对 10.3.1. 服务器字符集和校对 10.3.2. 数据库字符集和校对 10.3.3. 表字符集和校对 10.3.4. 列字符集和校对 10.3.5. 字符集和校对...
noexcept语法解析
lzq8090的博客
03-27 2078
noexcept 是一个 C++11 引入的关键字，用于表示一个函数或表达式在执行期间是否会抛出异常。它可以作为函数的一部分声明，也可以作为表达式的一部分使用。
c++ 异常捕获
zxcvb036的博客
07-13 144
#include <iostream> #include<string> #include<exception> using namespace std; class B { B(); virtual void method()const noexcept =0; // if the base class method with "noexcept",the derived class's method need set "noexcep.
C++实现智能指针部分功能(UniquePtr, SmartPtr, WeakPtr), head only（更新中）
CoderZhuuu
05-10 282
先放代码 #pragma once #include <memory> /* For std::move, std::forward, std::unique_ptr */ #include <utility> /* For std::exchange */ #include <type_traits> /* For template check */ #include <atomic> /* For std::atomic */ /* Deleter
C++深度探索 - shared_ptr源码分析
Huuaaaaa的博客
01-13 1157
简要分析 gcc 4.9.0版本下 shared_ptr源码。
使用lambdaquery() 报空指针异常_C++的异常处理
weixin_39972996的博客
11-28 558
背景传统的C代码中，当我们处理异常情况的时候，我们使用的是函数返回值，或者是非局部的errno变量来指示一个错误或者异常的发生。而在C++中，我们引入了try、throw、catch关键字组成的异常处理机制，而且已经习以为常。但是，在异常处理这类问题中，为什么函数返回值不够好用，以至于我们需要新引入try catch呢？原因大概这几方面：传统的代码中，处理异常的代码和正常的逻辑代码交织在一起，代码...
C++11 noexcept 关键字用法学习
null_10086的博客
08-08 2303
最近学习和写了一个 mint 的板子 ，其中用到了 noexcept 关键字，对这个关键字不太熟悉，便学习一下刘毅学长的文章。 C++98 中的异常规范（Exception Specification）傲芙小说网 https://www.3973.info throw 关键字除了可以用在函数体中抛出异常，还可以用在函数头和函数体之间，指明当前函数能够抛出的异常类型，这称为异常规范，有些教程也称为异常指示符或异常列表。请看下面的例子： double func1 (char param) throw(in..
C++11 之 noexcept
weixin_45782027的博客
03-29 236
noexcept是 C++11 中引入的一个关键字，它用于指示一个函数是否会抛出异常。使用noexcept可以使代码更加可靠和可预测，从而提高代码的可维护性和稳定性。我们应该注意使用方式和注意事项，使用好noexcept关键字可以使代码更健壮，更高效。
c++11的constexpr关键字 literal(常量)
happy_xiahuixiax的博客
04-23 2636
a constant expression is an expression whose value can’t change and that can be evaluated at a compile time. a literal is a constant expression. whether a given object or expression is a constant expr
深入理解c++11:c++11新特性解析与应用.pdf
最新发布
11-08
《深入理解c 11:c 11新特性解析与应用.pdf》是一本介绍C 11新特性的技术书籍。C 11是C语言的一次重要更新，引入了许多新的语言特性和标准库函数，以改进C语言的易用性和功能。 这本书通过详细解析C 11的新特性，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值