美文网首页C++
c++ 面向对象基础知识

c++ 面向对象基础知识

作者: 倔强swj | 来源:发表于2019-02-09 11:15 被阅读7次

    面向对象

    访问控制与封装

    • 定义在public说明符之后的成员可在整个程序内被访问。
    • 定义在private之后的成员可以被类的成员函数访问。

    struct 或 class 关键字,定义的类的所有成员都是public的时候,那么使用struct。反之,如果希望成员是private的,使用class。

    友元

    类想把一个函数作为它的友元,只需要增加一个friend关键字开始的函数声明语句即可。

    友元声明只能出现在类定义的内部,但是在类内出现的具体位置不限,友元不是类的成员,不受它所在区域访问控制级别的约束。

    封装的益处:

    • 确保用户代码不会无意间破坏封装对象的状态
    • 被封装地类的具体实现细节可以随时改变,而无须调整用户级别的代码。

    友元的声明

    ​ 友元的声明仅仅指定了访问的权限。而非一个通常意义上的函数声明,如果我们希望类的用户能够调用某个友元函数,那么我们就必须在友员声明之外再专门对函数进行一次声明。

    类之间的友元关系

    ​ 如果一个类指定了友元类,则友元类的成员函数可以访问此类包括非公有成员在内的所有成员。

    函数重载和友元

    ​ 如果一个类想把一组重载函数声明成它的友元,它需要对这组函数中的每个分别声明。

    令成员作为内联函数

    class Screen {
        public:
            typedef std::string::size_type pos;
            Screen() = default;
            
            Screen(pos ht, pos wd, char c): height(ht), width(wd), contents(ht * wd, c) {}
            char get() const {return contents[cursor]; } // 隐式内联
            inline char get(pos ht, pos wd) const;  // 显式内联
            Screen &move(pos r, pos c);     // 能在之后设为内联
        private:
            pos cursor = 0;
            pos height = 0, width = 0;
            std::string contents;
    }
    
    inline &Screen::move(pos r, pos c)      // 可以在函数的定义处指定inline
    {
        pos row = r * width;
        cursor = row + c;
        return *this;                       //以左值形式返回对象
    }
    
    char Screen::get(pos r, pos c) const    // 在类的内部声明成inline
    {
        pos row = r * width;
        return contents[row + c];
    }
    

    隐式的类类型转换

    另一个是从istream到Sales_data的转换:

    // 使用istream构造函数创建一个函数传递给combine

    item.combine(cin) 这段代码隐式的把cin 转换成 Sales_data, 这个转换执行了一个istream 的 Sales_data 构造函数,该构造函数通过读取标准输入创建了一个临时的Sales_data对象,随后将得到的对象传递给combine。

    抑制构造函数定义的隐式转换

    在要求隐式转换的程序上下文中,我们可以通过将构造函数声明为explicit加以阻止:

    class Sales_data {
        public:
            Sales_data() = default;
            Sales_data(const std::string &s, unsigned n, double p):bookNo(s), units_sold(n),revenue(p*n) {}
            explicit Sales_data(const std::string &s):bookNo(s){}
            explicit Sales_data(std::istream&);
    }
    

    此时没有任何构造函数能用于隐式转换的创建Sales_data 对象, 之前的用法item.combine(cin) 无法通过编译;

    关键字explicit 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换,所以无须将这些构造函数指定为explicit的。只能在类内声明构造函数时使用explicit关键字,在外部定义时不能重复。

    explicit 构造函数只能用于直接初始化而不能使用explicit 构造函数来执行拷贝形式的初始化。

    尽管编译器不会将explicit 的构造函数用于隐式转换过程,但是我们可以使用这样的构造函数显示的强制进行转化

    item.combine(static_cast<Sales_data>(cin));
    // 正确,static_cast 可以使用 explicit 的构造函数。
    

    聚合类

    • 要求类所有成员都是public

    • 没有定义任何构造函数

    • 没有类内初始值

    • 没有基类,没有virtual函数

      struct Data {
          int ival;
          string s;
      }
      Data val1 = {0, "Anna"};
      

    字面值常量类

    • 数据成员必须是字面值类型
    • 类必须是含有一个constexpr构造函数
    • 类必须使用析构函数的默认定义,该成员负责销毁类的对象。
    • 如果一个数据成员含有类内初始值,则内置类型成员的初值必须是一条常量表达式;

    类的静态成员

    声明静态成员

    • 静态成员可以是public的 或者是 private 的,静态数据成员的类型可以使常量,引用,指针,类类型等。

    • 类的静态成员存在于任何对象之外,对象中不包含任何与静态数据成员有关的数据。

    • 静态成员函数也不与任何对象绑定在一起,它们不包含this指针。作为结果,静态成员函数不能声明为const的,而且我们也不能再static 函数体内使用this指针。

    • 在类的外部定义静态成员时,不能重复static关键字,该关键字只能出现在类内部的声明语句中。

    • 因为静态数据成员不属于类的任何一个对象,所以它们不是在创建类的对象时被定义的。这意味着它们不是由类的构造函数初始化的。而且一般来说我们不能再类的内部初始化静态成员,相反的,必须在类的外部定义和初始化每个静态成员。

    • 静态数据成员和全局变量类似,一旦被定义,就存在于程序的整个生命周期

    • 静态数据成员可以作为默认实参,非静态数据成员不能。

    静态成员的类内初始化

    静态成员可以通过const整数类型的类内初始值进行初始化。要求静态成员必须是字面值常量类型的constexpr。初始值必须是常量表达式。

    class Account {
        private:
            static constexpr int period = 30;
    }
    

    拷贝控制

    class Foo {
        public: 
            Foo();
            Foo(const Foo&); // 拷贝构造函数
    }
    

    [1] C++ primer 中文版 第五版笔记

    相关文章

      网友评论

        本文标题:c++ 面向对象基础知识

        本文链接:https://www.haomeiwen.com/subject/kxbasqtx.html