C++2.0部分新特性

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++2.0部分新特性，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8187字，纯文字阅读大概需要12分钟。

内容图文

uniform initialization一致性初始化

//赋初值
vector<int>v1{ 1, 12, 6, 0 };
vector<string>v2{ "liming", "jenny", "denny" };

编译器看到以上{}赋值，就会做出一个initializer_list<T>，它的背后是一个array<T,n>，所有容器都有一个参数为initializer_list<T>的构造函数，当用户使用{}来初始化时，编译器会调用那个构造函数。

vector的构造函数

  vector(std::initializer_list<value_type> ilist)
  {
    range_init(ilist.begin(), ilist.end());
  }

range_init函数里面会先申请一段连续的空间，把begin和end里的数据一个一个的拷贝到新空间里。

class Person
{
public:
    Person(int a, int b) :m_A(a), m_B(b){}
    void  showPerson()
    {
        cout << m_A << " " << m_B << endl;
    }
private:
    int m_A;
    int m_B;
};
void test01()
{
    Person p{ 1, 2,};
    p.showPerson();
}

person的构造函数没有设置为带有initializer_list<T>的参数，这两个元素也会被分配给它的构造函数。

initialzer lists

void print1(std::initializer_list<int>val)
{
    for (auto p = val.begin(); p != val.end(); p++)
        cout << *p << endl;
}
print1({ 1, 2, 3, 4, 5, 6 });

explicit

　　在2.0之前的用法：

　　用来禁止使用隐式转化法，explicit只能修饰单一实参。

　　未使用explicit来修饰构造函数的demo

struct person{
    int m_a;
    int m_b;
    person(int a, int b=0) :m_a(a), m_b(b){   
        cout << "person的有参构造" << endl;
    }
    person operator+(const person&p)
    {
        //return person((m_a + p.m_a), (m_b + p.m_b));
        this->m_a =m_a+ p.m_a;
        this->m_b = m_b+p.m_b;
        return *this;
    }
};
void test01()
{
    person p(4,9);
    person p1 = p + 5;  //5传递给person &p时会调用构造函数
    cout << "p1的m_a=" << p1.m_a << " " << "m_b=" << p1.m_b << endl;
}

//打印结果
//person的有参构造
//person的有参构造
//p1的m_a=9 m_b=9

　　如果用explicit修饰构造函数，是告诉编译器不要自作聪明帮我做隐式转换。

explicit person(int a, int b=0) :m_a(a), m_b(b){
        cout << "person的有参构造" << endl;
    }

　　这时候再调用operator+会报错。二进制“+”: 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)

　　在2.0之后，explicit可以修饰多实参构造函数。

for的特殊用法

    for (auto i : { 1, 2, 3, 4, 5 })
        cout << i << " ";                 //1 2 3 4 5 
    cout << endl;
    vector<int>v{ 1, 2, 3, 4, 5 };
    for (auto i : v)
        cout << i << " ";          //1 2 3 4 5
    cout << endl;

源码

for(auto _pos=coll.begin(),auto _end=coll.end();_pos!=_end;_pos++)
{
    decl=*_pos ;
    ...
}

for的特殊用法与explicit

class p
{
public:
    p(string str)
    {
        m_name = str;
    }
    string m_name;
};
ostream &operator<<(ostream &cout,const p&pp)
{
    cout << pp.m_name;
    return cout;
}
vector<string> myv{ "liming", "jenny", "denny" };
    for (const p& elem : myv)  //这里会发生赋值，会调用构造函数
        cout << elem << " ";
cout << endl;

如果我们不希望for loop发生类型转换，就在构造函数前面加explicit，这时在赋值操作时就不会发生类型转换。

using

type alias

using func=void(*)(int,int); //func是一个函数指针，指向返回值为void,参数为int,int

void foo(int a,int b){...}
func=foo;

//标准库某容器
template<class T>
class c
{
     using value_type=T;  //等价于 typedef  T  value_type;      
}

noexcept

void foo()  noexcept
{
  ...
}

告诉编译器，本函数不会抛出异常。尤其是在设计一个class时，如果他要用vector这中容器，在设计类的move constructor和 move operator=时要告诉编译器我两个函数不会抛出异常，如果不声明为noexcept，编译器可能不敢用这两个函数，那么vector在成长过程要要做大量的拷贝构造。

class person
{
public:
    person()
    {
        cout << "person的默认构造" << endl;
    }
    person(int age)
    {
        m_age = new int(age);
        cout << "person的有参构造" << endl;
    }
    //搬离构造
    person(person&&p) _NOEXCEPT
    {
        cout << "move" << endl;
        m_age = p.m_age;
        p.m_age = nullptr;
    }
    //搬离赋值
    person &operator=(person&&p) _NOEXCEPT
    {
        cout << "move=" << endl;
        if (this != &p)
        {
            this->m_age = p.m_age;
            p.m_age = nullptr;
        }
        return *this;
    }
                   ...
}；

override

　　在子类重写父类虚函数时，明确告诉编译器我是在重写，如果不小心写错了参数，编译器会帮助我纠错。

class Base
{
     virtual  void func();   
}
class Son:public Base
{
   void func(int) override{}  //编译器会报错
}

final

　　两种用法：一种用来修饰类，被fianl修饰的class不能被继承；一种用来修饰虚函数，此虚函数不能被子类重写。

右值引用

　　Rvalue Reference帮助解决不必要的拷贝。当拷贝的来源端是右值，那么接收方就可以去“偷”来源端的数据，接收方就不必去申请新的空间来存放这些数据。

　　左值一般就是变量，放在左边接受数据，与之相对应就是右值，比如临时对象，右值只能放在右边。

　　C++新特性认为，当右值出现在operator=的右边，这时对右值进行move，而非拷贝是可行的。这时需要用户在调用端告诉编译器等号右边是个右值，并且在被调用端写出处理这个右值的move assignment。

　　举个例子，我们自定义了一个类，类中有属性开辟到堆区。

class Person{
public:
    Person()
    {
        cout << "person的默认构造函数" << endl;
    }
    Person(int age)
    {
        m_Age = new int(age);
        cout << "person的有参构造" << endl;
    }
    Person(const Person&p)
    {
        m_Age = new int(*p.m_Age);
        cout << "person的拷贝构造" << endl;
    }
    ~Person()
    {
        if (m_Age != NULL)
        {
            cout << "person的析构函数" << endl;
            free(m_Age);
            m_Age = NULL;
        }
    }
    int *m_Age;
};

    Person p1(22);
    Person p2(13);
    Person p3(34);
    Person p4(23);
    vector<Person>v1;
    v1.emplace(v1.begin(), p1);  //在容器起始位置插入一个元素，这个p1并不会当成右值

打印结果

C++2.0部分新特性 - 文章图片

发现他调用了拷贝构造函数。并没有去“偷”要放进来的p1。

C++2.0新特性可以允许我们这样写

class Person{
public:
    Person()
    {
        cout << "person的默认构造函数" << endl;
    }
    Person(int age)
    {
        m_Age = new int(age);
        cout << "person的有参构造" << endl;
    }
    Person(const Person&p)
    {
        m_Age = new int(*p.m_Age);
        cout << "person的拷贝构造" << endl;
    }
    Person(Person &&p)//c++2.0会调用这个构造函数
    {
        m_Age = p.m_Age;
        p.m_Age = NULL;
        cout << "person的move构造函数" << endl;
    }
    ~Person()
    {
        if (m_Age != NULL)
        {
            cout << "person的析构函数" << endl;
            free(m_Age);
            m_Age = NULL;
        }
    }
    int *m_Age;
};

    Person p1(22);
    Person p2(13);
    Person p3(34);
    Person p4(23);
    vector<Person>v1;
    v1.emplace(v1.begin(), move(p1)); //把p1当成右值

C++2.0部分新特性 - 文章图片

从打印结果来看，并没有调用拷贝构造，而是调用move构造函数，这是个浅拷贝，把要插入的值当作是右值，把它的地址原封不动的赋值过来，为了避免浅拷贝的问题，把右值里的指针清空。成功把右值“偷”过来了。

源码分析

C++2.0部分新特性 - 文章图片

variadic templates

　　模板参数和个数不定

void print()
{

}
template<typename T,typename ...Types>
void print(const T&firstArg,const Types&...args)
{
    cout << firstArg << " ";
    print(args...);
}
void test01()
{
    print(1.1, "liming", 100);  //打印 不同类型的数据
}

type_traits

　　在标准库中最主要的用法是判断一个类型他的拷贝构造、拷贝赋值、移动构造、移动赋值、析构函数重不重要。

测试：

//没有写拷贝构造、拷贝赋值、移动构造、移动赋值
class Person
{
public:
    Person() = default;
    Person(int age)
    {
        m_age=new int(age);
    }
    ~Person()
    {
        if (m_age != NULL)
        {
            delete m_age;
            m_age=NULL;
        }
            
    }
    int *m_age;
};
    cout << is_trivially_copy_constructible<Person>::value << endl;//判断person类的拷贝构造重不重要，1表示不重要，0表示重要
    cout << is_trivially_copy_assignable<Person>::value << endl;
    cout<<is_trivially_move_assignable<Person>::value << endl;
    cout << is_trivially_move_constructible<Person>::value << endl;
    cout << is_trivially_destructible<Person>::value << endl;

打印结果：1 1 1 1 0

class Person
{
public:
    Person() = default;
    Person(int age)
    {
        m_age=new int(age);
    }
    Person(const Person&p) //拷贝构造
    {
        m_age = new int(*p.m_age);
    }
    Person(Person &&p) //移动构造
    {
        m_age = p.m_age;
        p.m_age = NULL;
    }
    Person &operator=(const Person&p) //拷贝赋值
    {
        if (m_age != NULL)
        {
            delete m_age;
            m_age = NULL;
        }
        m_age = new int(*p.m_age);
        return *this;
    }
    Person &operator=(Person&&p)//移动赋值
    {
        if (this != &p)
        {
            if (m_age != NULL)
            {
                delete m_age;
                m_age = NULL;
            }
            m_age = p.m_age;
            p.m_age = NULL;
            return *this;
        }
    }

    ~Person()
    {
        if (m_age != NULL)
        {
            delete m_age;
            m_age=NULL;
        }
            
    }
    int *m_age;
};

打印结果：0 0 0 0 0 ，表示全都重要。

tuple

　　tuple是容纳元素集合的对象，这些元素可以是任意个数也可以是任意类型。

    std::tuple<int, float, double>t(1, 1.111, 2.0001);
    std::cout << "t:" << std::get<0>(t) << "  "
        << std::get<1>(t) << "  " << std::get<2>(t) << std::endl;
    auto t2= std::make_tuple(10, 1.1, "liming"); //构建一个变量名为t2的tuple
    std::cout << "t:" << std::get<0>(t2) << "  "
        << std::get<1>(t2) << "  " << std::get<2>(t2) << std::endl;
    int i;
    double d;
    std::string name;
    std::tie(i, d, name) = t2;  //将t2中的数据分别绑定到括号中的变量里
    std::cout << "i=" << i << " " << "d=" << d << " name= " << name << std::endl;
    
    typedef std::tuple<int, double, std::string>  TupleType;
    std::cout << "tuple_size=" << std::tuple_size<TupleType>::value << std::endl;

C++2.0部分新特性 - 文章图片

tuple源码

    template<typename... Values> class tuple;
    template<>class tuple<>{};

    template<typename Head, typename... Tail>
    class tuple<Head, Tail...>:private tuple<Tail...>
    {
        typedef tuple<Tail...> inherited;
    public:
        tuple(){}
        tuple(Head v, Tail... vtail)
        {
            m_head = v;
            inherited(vtail...);
        }
        Head head(){ return m_head; }
        inherited &tail()
        {
            return *this;
        }
    protected:
        Head m_head;
    };

C++2.0部分新特性 - 文章图片

内容总结

以上是互联网集市为您收集整理的C++2.0部分新特性全部内容，希望文章能够帮你解决C++2.0部分新特性所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/613495.html

来源：【匿名】

【上一篇】c++ 通讯录管理系统源码【下一篇】c++有个库什么的吗?

更多 ►

【C++2.0部分新特性】教程文章相关的互联网学习教程文章

C98或C99中的库为：<cassert> 或<assert.h>运行时断言，故明思议是当程序在运行的时候才作为判决，可以认为是对参数的有效性的判断。而静态断言，是对参数的条件判断提前做了，在预编译的时候进行完成的。如：//demo1.cpp #include <cassert>usingnamespace std;char *arrayAolloc(int n){assert(n>0); returnnewchar [n]; }int main(){char * a = arrayAolloc(0);return0; }//gcc demo1.cpp -omainassert(n>0); 该条件只会在当arr...

C++11新特性【代码】

1、结构体内直接赋初始值struct Student{char* name = nullptr;unsigned int age = 15;int number = 21509111; };如此一来，所有声明的新结构体对象就是默认上面的值。原文：https://www.cnblogs.com/fuqia/p/9538273.html

c++11新特性【代码】

编译环境：Windows 10 + elclipse +gcc-8.1.01、类型推导C++11 引入了 auto 和 decltype 这两个关键字实现了类型推导，由编译器在编译过程中完成类型推断过程。区别： 1）语法格式区别auto varname = value; 　　　　　　　　// auto 根据=右边的初始值 value 推导出变量的类型，且varname必须初始化。 decltype(exp) varname = value;　　 // decltype 根据 exp 表达式推导出变量的类型，跟=右边的 value 没有关系。原则上，exp ...

转载 C++11新特性学习【代码】

自己一直用的是C++98规范来编程，对于C++11只闻其名却没用过其特性。近期因为工作的需要，需要掌握C++11的一些特性，所以查阅了一些C++11资料。因为自己有C++98的基础，所以从C++98过渡到C++11并不算特别吃力，读了一些书籍后，算是对C++11有了个比较基础的理解，感觉程序员还是要经常保持新语言新特性的更新，现在 C++ 标准都出到C++17了！这篇文章就是对C++11一些常用新特性的一些总结，以C++98和 C++11在语法上的差异来突出C++1...

C++11新特性（1）右值引用【图】

在C++中，左值(lvalue)是可以获取其地址的一个量。由于经常出现在赋值语句的左边，因此称之为左值。例如一个有名称的变量。例如：int a=10;//a就是一个左值。传统的C++引用，都是左值引用。例如：int &ra=a;将ra关联到a。这就是左值引用。 C++11，新增了右值引用的概念。用&&代表右值引用。首先我们来看一下什么叫做右值。可以说所有不是左值的量都是右值。例如文本，临时对象或者临时值(都是不能获取地址的量)。 ...

【C++11】新特性——Lambda函数【代码】

本篇文章由：http://www.sollyu.com/c11-new-lambda-function/文章列表本文章为系列文章【C++11】新特性——auto的使用 http://www.sollyu.com/c11-new-features-auto/【C++11】新特性——Lambda函数 http://www.sollyu.com/c11-new-lambda-function/说明在标准 C++，特别是当使用 C++ 标准程序库算法函数诸如 sort 和 find，用户经常希望能够在算法函数调用的附近定义一个临时的述部函数(又称谓词函数，predicate function)。由于...

【C++11新特性】 C++11智能指针之weak_ptr

如题，我们今天要讲的是C++11引入的三种智能指针中的最后一个：weak_ptr。在学习weak_ptr之前最好对shared_ptr有所了解。 1、为什么需要weak_ptr？在正式介绍weak_ptr之前，我们先来回忆一下shared_ptr的一些知识。我们知道shared_ptr是采用引用计数的智能指针，多个shared_ptr实例可以指向同一个动态对象，并维护了一个共享的引用计数器。对于引用计数法实现的计数，总是避免不了循环引用（或环形引用）的问题，shared_ptr也不例...

C++11 新特性之序列for循环【代码】

在C++中在C++中for循环能够使用相似java的简化的for循环,能够用于遍历数组,容器,string以及由begin和end函数定义的序列(即有Iterator)#include <iostream> #include <map> #include <string> using namespace std;int main() { map<string, int> ms;ms.insert(make_pair("a", 1));ms.insert(make_pair("b", 2));ms.insert(make_pair("c", 3));ms.insert(make_pair("d", 4));for (auto itr: ms)cout << itr.first << ":" << itr.sec...

c++11新特性std::function、std::bind封装可执行对象【代码】【图】

转载：https://www.cnblogs.com/feng-sc/p/5710724.html#title11 std::bind和std::function也是从boost中移植进来的C++新标准，这两个语法使得封装可执行对象变得简单而易用。此外，std::bind和std::function也可以结合我们一下所说的lamda表达式一起使用，使得可执行对象的写法更加“花俏”。我们下面通过实例一步步了解std::function和std::bind的用法：Test.h文件//Test.h 示例代码1.0 http://www.cnblogs.com/feng-sc/p/571072...

C++11部分新特性总结【代码】

在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于TC1主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个...

C++11 新特性【代码】

经过作者的不断迭代，一本书往往会先后发布很多个版本，其中每个新版本都是对前一个版本的修正和更新。C++ 编程语言的发展也是如此。截止到目前（2020 年），C++ 的发展历经了以下 3 个个标准： 2011 年，新的 C++ 11 标准诞生，用于取代 C++ 98 标准。此标准还有一个别名，为“C++ 0x”；2014 年，C++ 14 标准发布，该标准库对 C++ 11 标准库做了更优的修改和更新；2017 年底，C++ 17 标准正式颁布。 C++11 是第二个真正意义上的 ...

C++新特性 shared_ptr与weak_ptr【代码】

/*shared_ptr 与weak_ptr */ #include <memory> #include <iostream>void foo_construct() {int * p = new int(3);std::shared_ptr<int> sptr(p);std::shared_ptr<int> sptr2(new int(4));std::shared_ptr<int> sptr3 = sptr2; //指针引用加1std::shared_ptr<int> sptr4 = std::make_shared<int>(5);/*{std::shared_ptr<int> sptr5(p);{std::shared_ptr<int> sptr6(p);}}//这么写会报错，原因生活会，因为5和6都是指向同一个对象，...

C++新特性探究(13.5)：右值引用【代码】【图】

运行结果：附上例代码： //小问学编程 //左值：在内存中有确切位置的值 //右值：是一个暂时存在的值 #include <iostream> using namespace std;int main() {int a(10);//a在内存中有地址，数据是10int b(11);//b在内存中有地址，数据是11int c=a+1;//&(a+1)没有内存地址，是一个临时的值，是一个右值。仅短暂存在于寄存器中int d=a+2;//int& f=c; //左值引用&——是对内存值的引用int&& g=a+3;//右值引用&&——是对暂时存在值的...

张三思评博客：C++11新特性快看-乱序优化版【代码】

标题: 【C++ Primer】C++11特性总结作者: lx青萍之末原文链接: https://blog.csdn.net/daaikuaichuan/article/details/79240196 文章目录 * 1、long long 类型 * 2、列表初始化 * 3、nullptr 空指针 * 4、constexpr变量 * 5、constexpr函数 * 6、using类型别名 * 7、auto类型指示符 * 8、decltype类型指示符 * 9、范围for语句 * 10、尾置返回类型 * 11、强枚举类型 * 12、=default 生成默认构造函数 * 13、类对象成员的类内初始化...

C++新特性

C++2b 功能特性请注意，随 C++2b 标准草案的逐步推进，此列表可能会发生变化。 C++23 核心语言功能特性 C++23 功能特性提案GCCClangMSVCApple ClangEDG eccpIntel C++IBM XLC++Sun/Oracle C++Embarcadero C++ BuilderCrayPortland Group (PGI)Nvidia nvcc[折叠]（有符号） size_t的字面量后缀P0330R8C++23 功能特性提案GCCClangMSVCApple ClangEDG eccpIntel C++IBM XLC++Sun/Oracle C++Embarcadero C++ BuilderCrayPortland Grou...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / C++2.0部分新特性

C++2.0部分新特性

内容导读

内容图文

uniform initialization一致性初始化

initialzer lists

explicit

for的特殊用法

using

noexcept

override

final

右值引用

variadic templates

type_traits

tuple

内容总结

内容备注

内容手机端

【C++2.0部分新特性】教程文章相关的互联网学习教程文章

C++11 新特性，运行时断言与静态断言【代码】

C++11新特性【代码】

c++11新特性【代码】

转载 C++11新特性学习【代码】

C++11新特性（1）右值引用【图】

【C++11】新特性——Lambda函数【代码】

【C++11新特性】 C++11智能指针之weak_ptr

C++11 新特性之序列for循环【代码】

c++11新特性std::function、std::bind封装可执行对象【代码】【图】

C++11部分新特性总结【代码】

C++11 新特性【代码】

C++新特性 shared_ptr与weak_ptr【代码】

C++新特性探究(13.5)：右值引用【代码】【图】

张三思评博客：C++11新特性快看-乱序优化版【代码】

C++新特性

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程