首页 > 代码库 > 格式工厂(一)

格式工厂(一)

版权声明:本文为博主原创文章,未经博主允许不得转载。

本节主要介绍C++的新特性,对于C++的基础语法不再讲解.由于编译器的不同.在某些地方可能有些差异,但是无太大影响.

讲解本节知识之前先确认你的C++支持度[__cplusplus]

#include <iostream>
int main(int argc, const char * argv[]) {
    std::cout<<__cplusplus<<std::endl;
    return 0;
}  

 会看到这样,说明支持C++11

技术分享


 

新特性 1  模板套模板

在旧版本的C++中模板套用模板可能要加空格,像这样

vector<list<int> > //旧板中需要加空格
vector<list<int>>  //新模板中不需要加

新特性 2  空指针

新规定中nullptr可以代替0和NULL(0指针)

void f(int)   { cout << "f(int) be called" << endl; }
void f(void*) { cout << "f(void*) be called" << endl; }

f(0);       //calls f(int)
f(NULL);    //calls f(int) if NULL is 0
f(nullptr); //calls f(void*) 

 

新特性 3  新auto

1.自动识别类型(编译器的实参推倒)

auto i = 42; //自动识别 i为 int
auto d = func(); //自动识别d为函数返回值

2.如果初始化表达式是引用,则去除引用语义.如果auto关键字带上&号,则不去除const语意

int a = 10;
int &b = a;

auto c = b;//c的类型为int而非int&(去除引用)
auto &d = b;//此时c的类型才为int&

 

3.如果初始化表达式为const或volatile,则除去const/volatile语义.

const int ci=i,&cr=i;
auto a=ci;      //a为int(忽略顶层const)
auto b=cr;      //b为int(忽略顶层const,cr是引用)
auto c=&i;      //c为int *
auto d=&ci;     //d是pointer to const int(&ci为底层const

 

4.初始化表达式为数组时,auto关键字推导类型为指针.

int main()
{
    int array[3]{ 1, 2, 3 };
    auto array_b = array;
    std::cout << typeid(array_b).name() << std::endl;
    
    return 0;
}

 输出结果Pi(int*)

技术分享

注意事项

1.auto声明的变量必须要初始化,否则编译器不能判断变量的类型.

2.auto不能被声明为返回值(但可以与decltype结合使用做返回值的站位下文有),auto不能作为形参,auto不能被修饰为模板参数


 

新特性 4  新初始化

C++11之前的初始化

Rect r1 = {3,7,20,25};//大括号
Rect r2(3,7,20,25) ;//小括号
int arry[3] = {1,2,3};//[]

C++11之后一切的初始化都可以用 {} 代替

int value[] {1,2,3};
vector<int> v {1,2,3};
complex<double> c {1,2,3};

新初始化的优点

int i; //初始值不知道
int i{}; //初始值是0
int * p;//初始值不知道
int * p{}; //初始值是nullptr

//{}  不允许窄化转换
int x1(5.3);它会被初始化为5
int x2{5.3};它会报错

 


 

 新特性 5  initializer_list<>

一包东西,但是类型得是相同的,实现C++源码的重要语法,知道怎么用就可以.传递过程不需要我们担心,编译器会自动处理

int main(int argc, const char * argv[]) {
    std::initializer_list<int> t1 {1,2,3,4};
    std::cout<<max(t1)<<std::endl;//新的max() 传参采用 initializer_list 不在受限于参数个数
    return 0;
}

 

  输出结果

技术分享


 新特性 6   新for循环

新的for循环采用for(del声明 : coll容器),与旧for()不冲突

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1 {1,2,3,4,5};
    for (auto i: v1) {
        std::cout<< i <<std::endl;
    }
    return 0;
}

输出结果

技术分享


 

新特性 7  =default与=delete

class Zoo//delete删掉编译器给的 default要编译器给的即使定义了也要让编译器给出
{
public:
    Zoo(int i1,int i2) : d1(i1),d2(i2) {}
    Zoo(const Zoo&) = delete;//拷贝构造函数
    Zoo(Zoo&&) = default;//右值引用 Move()
    Zoo & operator = (const Zoo&) = default;
    Zoo operator = (const Zoo&&) = delete;
    virtual ~Zoo();
    
private:
    int d1,d2;
};

 

a.  =default用于普通函数无意义(构造函数可以共存)

b.  =delete用于普通函数可以取代于virtual function = 0

c.  BIG-Three 默认构造函数 默认拷贝构造函数 默认析够函数 他们三个函数的作用是给编译器防止一个幕后藏身的地方 如父类的构造函数调用过程.

    类中有指针成员,需要重写BIG-Three没有则不用

d.  类中讲拷贝构造与构造函数声明成private 如果你的类继承自noncopyable 那么你的类也不能被拷贝

简单实现一下noncopyable

class noncopyable  
{  
protected:  
    noncopyable (void)  {}  
    ~noncopyable (void)  {  }  
  
private:
    noncopyable (const noncopyable&);  
    const noncopyable& operator= (const noncopyable&);  
};

 


新特性 8  Alias Template(template typedef)

功能相当于取别名

template<typename T>
using vec = std::vector<T,std::allocator<T>>;
int main()
{
    vec<int> v1 {1,2,3,4};
    for(auto i: v1)
    {
        std::cout<< i <<std::endl;
    }
    return 0;
}

技术分享


 

新特性 9  Type Alias

类似于typedef,重新命名

typedef void (*func) (int, int);
using func = void(*) (int,int);//这两个函数意义相同 但是感觉using更容易让人理解

 

 

template <typename T>
struct Container {
    using value_type = T; // 相同于 typedef T value_type;
};

 

 


 

新特性 10  noexcept,override,final关键字

 

//noexcept 保证函数不会丢出异常
void foo() noexcept; //== void foo() noexcept(true) 括号内处条件  在完成什么条件下不会抛出异常
void swap(string & x ,string & y) noexcept(noexcept(x.swap(y)))
{
    x.swap(y);
}

class MyString
{
private:
    char * _data;
    size_t _len;

public:
    //move constructor  move语法必须用noexcept 尤其在vecotr上 不然不让编译 (voctor 是按传进参数个数成长 很容易在申请内存上出错) move意义上当于 by reference
    MyString(MyString&& str)noexcept : _data(str._data), _len(str._len){}
    MyString& operator= (MyString&&str) noexcept {return *this;}
    
};

 

 

//override 运用在虚函数上 自动识别是否是虚函数
struct Base
{
    virtual void vfunc(float){}
};
struct Drivedl:Base
{
    virtual void vfunc(float) override {}//自动识别该函数是否是基类中的虚函数 如果不是报错
};

 

 

//final 继承树下的最后一个  (没有人可以在继承它)
struct Base1 final{};//1.作用于类,该类不可被继承 
struct Base2
{
    virtual void f() final;//2.作用于函数 该虚函数不可以被重写
};

 


 

新特性 11  decltype

相当于type of (识别类型),然编译器去识别type,不能识别重载的函数

1.基本使用方法

int main() {
    auto num = 1;  //num 是int类型
    decltype(num) num2 = num; //num2 也是int类型
    return 0;
}

2..声明返回值类型

//判断两个参数相加的返回值类型
template<typename T1,typename T2>
auto add(T1 x, T2 y) -> decltype(x+y);

3. 做参数

class Person
{
public:
    Person(){};
    ~Person(){};
    
public:
    int m_age = 0;
    std::string lastname  = "";
    std::string firstname = "";
    
};

auto cmp = [](const Person& p1,const Person& p2)//lambda
{
    return p1.lastname<p2.lastname||
    (p1.lastname == p2.lastname && p1.firstname< p2.firstname);
};

int main()
{
    std::set<Person,decltype(cmp)> coll(cmp);
    Person * p1 = new Person;
    p1->lastname = "a";
    
    Person * p2 = new Person;
    p2->lastname = "b";
    
    Person * p3 = new Person;
    p3->lastname = "c";
    coll.insert(*p3);
    coll.insert(*p1);
    coll.insert(*p2);
    
    for (auto i: coll) {
        std::cout<<i.lastname<<std::endl;
    }
    
    return 0;
}

  输出结果

 技术分享

 参照<<侯捷 C++新标准 C++11>>

 如有不对请指正.

 

格式工厂(一)