首页 > 编程语言 > 详细

[C++]新特性

时间:2014-05-08 10:11:53      阅读:471      评论:0      收藏:0      [点我收藏+]

auto:自动类型推断和返回值占位,与c++98定义不同(临时变量定义)

bubuko.com,布布扣
//  auto a;                 // 错误,没有初始化表达式,无法推断出a的类型  
//  auto int a = 10;        // 错误,auto临时变量的语义在C++11中已不存在, 这是旧标准的用法。  
  
// 自动帮助推导类型  
    auto a = 10;  

//我们可以使用valatile,pointer(*),reference(&),rvalue reference(&&) 来修饰auto
auto k = 5; 
auto* pK = new auto(k);

//函数和模板参数不能被声明为auto

//不能用于类型转换或其他一些操作,如sizeof和typeid
int value = 123;  
auto x2 = (auto)value; // no casting using auto 

//定义在一个auto序列的变量必须始终推导成同一类型
auto x1 = 5, x2=a; //wrong

//auto不能自动推导成CV-qualifiers(constant & volatile qualifiers),除非被声明为引用类型
const int i = 99;  
auto j = i;       // j is int, rather than const int  
j = 100           // Fine. As j is not constant  
auto& k = i;      // Now k is const int&  
k = 100;          // Error. k is constant

//auto会退化成指向数组的指针,除非被声明为引用
int a[2]={0,1};
auto ar = a;
count<<typeid(ar).name()<<endl; // int

auto &ar = a;
count<<typeid(ar).name()<<endl; // int [2]
bubuko.com,布布扣

 

nullptr: 替代NULL的宏定义,VS2010之前的版本,不支持此关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//0(NULL)和nullptr可以交换使用,但是nullptr是一个为空的指针,并不是一个整形,不能替代0
int* p1 = 0; 
int* p2 = nullptr
  
if(p1 == p2) {} 
if(p2) {}
 
//不能将nullptr赋值给整形
int n2 = nullptr;       // error
if(0 == nullptr) {}    // error 
if(nullptr) {}    // error 
 
//重载时,使用nullptr时 对应的是参数为指针的函数
void foo(int)   {cout << "int" << endl;} 
void foo(char*) {cout << "pointer" << endl;} 
   
foo(0);       // calls foo(int) 
foo(nullptr); // calls foo(char*)

 

 

decltype

decltype(E)是一个标识符或者表达式的推断数据类型(“declared type”),它可以用在变量声明中作为变量的数据类型

 

 

override: 表示函数应当重写基类中的虚函数。

bubuko.com,布布扣
class B 
{
public:
   virtual void f(short) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override {std::cout << "D::f" << std::endl;}
};
//error:‘D::f‘ : method with override specifier ‘override‘ did not override any base class methods
bubuko.com,布布扣

 

final: 表示派生类不应当重写这个虚函数。

bubuko.com,布布扣
class B 
{
public:
   virtual void f(int) {std::cout << "B::f" << std::endl;}
};
 
class D : public B
{
public:
   virtual void f(int) override final {std::cout << "D::f" << std::endl;}
};
 
class F : public D
{
public:
   virtual void f(int) override {std::cout << "F::f" << std::endl;}
};
//被标记成final的函数将不能再被F::f重写
bubuko.com,布布扣

 

Strongly-typed enums

enum class Options {None, One, All}; //强类型枚举由关键字enum class标识,它不会将枚举常量暴露到外层作用域中,也不会隐式转换为整形
Options o = Options::All;

Smart Pointers 智能指针

bubuko.com,布布扣
unique_ptr: 如果内存资源的所有权不需要共享,就应当使用这个(它没有拷贝构造函数),但是它可以转让给另一个unique_ptr(存在move构造函数)。有点像auto_ptr
std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = std::move(p1); // transfer ownership

shared_ptr: 如果内存资源需要共享,那么使用这个
weak_ptr:持有被shared_ptr所管理对象的引用,但是不会改变引用计数值。它被用来打破依赖循环
auto_ptr: 已废弃
bubuko.com,布布扣

 

Lambda

bubuko.com,布布扣
[captures] (params) -> ret {Statments;}  

#include <iostream>  
  
using namespace std;  
  
int main()  
{  
    auto func = [] () { cout << "Hello world"; };  
    func(); // now call the function  
} 
/*
[] 不截取任何变量
[&} 截取外部作用域中所有变量,并作为引用在函数体中使用
[=] 截取外部作用域中所有变量,并拷贝一份在函数体中使用
[=, &foo]   截取外部作用域中所有变量,并拷贝一份在函数体中使用,但是对foo变量使用引用
[bar]   截取bar变量并且拷贝一份在函数体重使用,同时不截取其他变量
[this]            截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。
*/
string name;  
cin>> name;  
return global_address_book.findMatchingAddresses(   
    // notice that the lambda function uses the the variable ‘name‘  
    [&] (const string& addr) { return name.find( addr ) != string::npos; }   
); 
bubuko.com,布布扣

参考链接:http://blog.csdn.net/srzhz/article/details/7934652

 

控制默认函数——默认或者禁用

bubuko.com,布布扣
class X {
        //

        X& operator=(const X&) = delete;   // 禁用类的赋值操作符
        X(const X&) = delete;
    };

//但是其实可以用privae啊!
bubuko.com,布布扣

 

std::bind

bubuko.com,布布扣
//bind()接受一个函数(或者函数对象,或者任何你可以通过”(…)”符号调用的事物),生成一个其有某一个或多个函数参数被“绑定”或重新组织的函数对象
int f(int, char, double);
// 绑定f()函数调用的第二个和第三个参数,
// 返回一个新的函数对象为ff,它只带有一个int类型的参数
auto ff = bind(f, _1, ‘c’, 1.2);
int x = ff(7);                //  f(7, ‘c’, 1.2);
//“_1″是一个占位符对象,用于表示当函数f通过函数ff进行调用时,函数ff的第一个参数在函数f的参数列表中的位置

//bind()也可以被看做是bind1st()和bind2nd()的替代品
bubuko.com,布布扣

 

std::function

bubuko.com,布布扣
struct X {
                int foo(int);
        };

        // 所谓的额外参数,
        // 就是成员函数默认的第一个参数,
        // 也就是指向调用成员函数的对象的this指针
        function<int (X*, int)> f;
        f = &X::foo;            // 指向成员函数

        X x;
        int v = f(&x, 5);  // 在对象x上用参数5调用X::foo()
        function<int (int)> ff = std::bind(f, &x, _1);    // f的第一个参数是&x
        v = ff(5);                // 调用x.foo(5)

//可以看做是C++98标准库中函数对象mem_fun_t, pointer_to_unary_function等的替代品
bubuko.com,布布扣

 

 

参考链接:http://blog.csdn.net/huang_xw/article/details/8764346 

http://blog.jobbole.com/44015/ 

[C++]新特性,布布扣,bubuko.com

[C++]新特性

原文:http://www.cnblogs.com/zengyou/p/3709790.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!