新普京网站-澳门新普京 > 前端 > 新特性之Class

新特性之Class

2019/12/29 18:01

sizeof

新规范中,sizeof能够一贯用来获取Class::member的轻重,而不用经过Class的实例。

class TestClass
{
public:
    int member_i;
    char member_c;
};

cout<<"test sizeof class member:n";
cout<<sizeof(TestClass::member_i)<<"t"<<sizeof(TestClass::member_c)<<endl;

delegate constructor

新专门的学问中,可以在最先化列表少校二个constructor伊始化的行事委托给另一个constructor。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}
    TestClass(const int i): TestClass(i, 0) { member_c = 'T';}

    int member_i;
    char member_c;
};

cout<<"test delegating constructor:n";
TestClass tc2(2);
cout<<tc2.member_i<<'t'<<tc2.member_c<<endl;

多再而三与私下认可constructor

多种世襲的子类能够大器晚成直接轨父类的结构函数,不过要是父类中有形参列表完全相似的布局函数,则会爆发冲突,这时候急需子类本人定义四个和好版本的结构函数。

class TestClass2
{
public:
    TestClass2() = default;
    TestClass2(const int i) {}
};

class MultiSubClass: public TestClass, public TestClass2
{
public:
    using TestClass::TestClass;
    using TestClass2::TestClass2;
    // conflicts with version inherited from ‘TestClass’
    MultiSubClass(const int i): TestClass(i) {}
    MultiSubClass() = default;
};

cout<<"test multi inherit constructor:n";
MultiSubClass mtc(1024);
mtc.print_msg();
return 0;

总结

  1. sizeof可以直接用于获取Class::member的大大小小,而不用经过Class的实例。
  2. 可以透过=default强逼编写翻译器生成二个暗中认可constructor。
  3. 能够在伊始化列表旅长二个constructor初阶化的工作委托给另几个constructor,以致父类的constructor。
  4. allocator.construct能够利用放肆的布局函数。
  5. 能够经过=default供给编写翻译器合成暗许的正片/赋值布局函数,也足以透过=delete幸免拷贝。
  6. 新专门的学问中提供了override和final八个举足轻重字,用于标记子类对父类中虚函数的重写(override)或防止重写(final),编写翻译会对那三种情景举办反省。final还是能够用于类的标记,表示禁绝继续。
  7. 多种世襲的子类能够间接接轨父类的结构函数,可是假诺父类中有形参列表完全相仿的构造函数,则会发出冲突,那时候须求子类自个儿定义贰个和好版本的结构函数。

完全代码详见class.cpp

override和final

新标准中提供了override和final八个根本字,用于标记子类对父类中虚函数的重写(override)或制止重写(final)。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}
    TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
    TestClass(const TestClass&) = default;
    TestClass& operator=(const TestClass&);

    virtual void print_msg() {cout<<member_i<<'t'<<member_c<<endl;}
    virtual void final_foo() final {}

    int member_i;
    char member_c;
};
TestClass& TestClass::operator=(const TestClass&) = default;

class SubTestClass final: public TestClass
{
    public:
        using TestClass::TestClass;
        SubTestClass(const int i): TestClass(i, 'S') {}
        void print_msg() override;
        //void print_msg(char c) override;
        //‘void SubTestClass::print_msg(char)’ marked override, but does not override

        //void final_foo() {}
        //overriding final function ‘virtual void TestClass::final_foo()’
};
//class SubSubTestClass: public SubTestClass {}; 
// cannot derive from ‘final’ base ‘SubTestClass’ in derived type ‘SubSubTestClass’

void SubTestClass::print_msg() 
{
    cout<<"i: "<<member_i<<'t'<<"c: "<<member_c<<endl;
}

cout<<"test override:n";
TestClass *stc_ptr = new SubTestClass(10); 
stc_ptr->print_msg();
SubTestClass stc(10);
TestClass tc6 = (TestClass)stc;
tc6.print_msg();

假诺标记了override的函数实际上未有重写父类中的函数,大概标志final的函数被子类重写,编写翻译器都会报错。

通样的,标记为final的类也分裂意作为父类被一连。

那是C++11新特色介绍的第六片段,涉及到Class的相关内容。

allocator.construct

新标准中,allocator.construct能够选择恣意的布局函数。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}
    TestClass(const int i): TestClass(i, 0) { member_c = 'T';}

    int member_i;
    char member_c;
};

cout<<"test allocator:n";
allocator<TestClass> alloc;
auto p = alloc.allocate(10);
alloc.construct(p, 10);
cout<<p->member_i<<'t'<<p->member_c<<endl;

委托父类布局函数

新专门的学业中,也帮忙子类在最初化列表中央机关单位接委托父类的构造函数完成发轫化。

class SubTestClass final: public TestClass
{
    public:
        using TestClass::TestClass;
        SubTestClass(const int i): TestClass(i, 'S') {}
        void print_msg() override;
};

cout<<"test inherit base class contructor:n";
SubTestClass stc2(1024, 'H');
stc2.print_msg();

不想看toy code的读者能够直接拉到作品最终看那有个别的下结论。

copy constructor

新标准中,能够通过=default必要编写翻译器合成暗中认可的正片/赋值构造函数。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}
    TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
    TestClass(const TestClass&) = default;
    TestClass& operator=(const TestClass&);

    int member_i;
    char member_c;
};

cout<<"test =default class copy construct:n";
TestClass tc3(tc2);
TestClass tc4 = tc2;
cout<<tc3.member_i<<'t'<<tc3.member_c<<endl;
cout<<tc4.member_i<<'t'<<tc4.member_c<<endl;

如出后生可畏辙,新标准中也允许用=delete幸免拷贝。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}
    TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
    TestClass(const TestClass&) = delete;
    TestClass& operator=(const TestClass&);

    int member_i;
    char member_c;
};
TestClass& TestClass::operator=(const TestClass&) = default;

cout<<"test =delete class copy construct:n";
//TestClass tc5(tc2); // error: use of deleted function ‘TestClass::TestClass(const TestClass&)’
//cout<<tc5.member_i<<'t'<<tc5.member_c<<endl;
cout<<"test =delete done."<<endl;

default constructor

新专门的工作中,能够通过=default强制编写翻译器生成三个私下认可constructor。

class TestClass
{
public:
    TestClass() = default;
    TestClass(const int i, const char c): member_i(i), member_c(c) {}

    int member_i;
    char member_c;
};

cout<<"test =default class construct:n";
TestClass tc; // may cause error if no default construct.
cout<<tc.member_i<<'t'<<(short)tc.member_c<<endl;
cout<<"test =default done."<<endl;

在上头的代码中,假若我们不提供暗中同意constructor的话,不或者透过TestClass tc定义一个实例。

上一篇:中Dictionary的内部实现剖析 下一篇:没有了