记录C++学习获得的经验点 2018/6/10-2018/6/16

绝地灬酷狼 2022-05-21 22:54 283阅读 0赞

## 类的一些特性 ##

知识点1：可通过typedef或using类可以自定义某种类型别名在类中

知识点2：如果我们需要合成的默认构造函数，在空列表的构造函数后加上=default即可

知识点3：类的成员也可以重载，参数列表数量或者类型上不同

知识点4：在变量前加关键字mutable，变为可变数据成员，即使是在一个const的对象函数中也可以被修改

知识点5：类内初始值，直接用=赋予的方式是C++11新特性，也就是VS2013以上的版本才支持

知识点6：当某个数据成员在构造函数初始化列表中忽略，它将以默认构造函数的方式隐式初始化，但需要有一个初始化值，否则应该显式的初始化

# 为什么使用size\_type类型 #

机器无关的(machine-independent)。  
与unsigned型（unsigned int或unsigned long）具有相同的含义，而且可以保证足够大可存储任意string对象的长度。  
为了使用由string类型定义的size\_type类型，程序员必须加上作用域操作符来说明所使用的size\_type类型是由string类定义的。  
**不要把size的返回值赋给一个int变量**  
unsigned型所能表示的最大正数值比对应的signed要大一倍。  
这个事实表明size\_type存储的string长度是int所能存储的两倍。  
使用int变量的另一个问题是，有些机器上int变量的表示范围太小，甚至无法存储实际并不长的string对象。如在有16位int型的机器上，int类型变量最大只能表示32767个字符的string对象。  
而能容纳一个文件内容的string对象轻易就会超过这个数字。因此，为了避免溢出，保存一个string对象size的最安全的方法就是使用标准库类型string:: size\_type。

string类类型和许多其他库类型都定义了一些配套类型（companion type）。通过这些配套类型，库类型的使用就能和机器无关（machine-independent）。string::size_type定义为unsigned型，可以保证足够大的存储string对象的长度。   
    
    注意，任何存储string的size操作结果的变量必须为string::size_type类型。尤其不能把size的返回值赋给一个int变量。（因为size返回的是一个unsigned类型，而int是signed类型。size能表达的大小是int的2倍）。

## 为什么使用inline函数 ##

inline内联函数目的是为了**解决程序中函数调用的效率问题**。一般函数进行调用时，要将程序的执行权转到被调用的函数中，然后再返回到调用它的函数中；而内联函数在进行调用时，是将调用表达式用内联函数体来替换。  
**类中函数默认是inline函数**  
在类中对于公共代码使用私有功能函数，可以避免在多处使用同样的代码减少代码量，在调试时只需要修改定义的函数，在类内的函数为内联函数并不会产生额外的开销。

## 类的练习-字符方阵 ##

using namespace std;
    class Screen {
    public:
        using pos = string::size_type;
        Screen() = default;
        Screen(pos wd, pos ht, char c) :height(ht), width(wd), contents(ht*wd, c) {}
        Screen(pos wd, pos ht) :height(ht), width(wd), contents(ht*wd, NULL) {}
        pos &getcursor() { return cursor; }
        char get() const { return contents[cursor]; }
        char get(pos r, pos c) { return contents[r*width + c]; }
        Screen &move(pos r, pos c) { cursor = ((r-1)*width + (c-1)); return *this; }
        Screen &set(char letter) { contents[cursor] = letter; return *this; }
        Screen &display(ostream &out) { do_display(out); return *this; }
        const Screen &display(ostream &out) const { do_display(out); return *this; }
    private:
        pos cursor{ 0 };
        pos height{ 0 }, width{ 0 };
        string contents;
        void do_display(ostream &out) const {
            for (pos index = 0; index != height * width; ++index) {
                if (index%width == 0)out << endl;
                out << contents[index] << " ";
            }
        }
    };
    int main(int *argc, char *argv) {
        string::size_type row_num, column_num, resetrow,resetcolumn;
        char start_letter, resetletter;
        cout << "输入字符方阵的行数: ";cin >> row_num;
        cout << "输入字符方阵的列数: "; cin >> column_num;
        cout << "输入每个单位的初始化字符: "; cin >> start_letter;
        cout << "输入要改变字符单位的所在行数: "; cin >> resetrow;
        cout << "输入要改变字符单位的所在列数: "; cin >> resetcolumn;
        cout << "输入要改变成的字符: "; cin >> resetletter;
        Screen myScreen(row_num,column_num,start_letter);
        myScreen.move(resetrow, resetcolumn).set(resetletter).display(cout);
        cout << endl;
        myScreen.display(cout);
        cout << endl;
        return 0;
    }

## this指针的好与坏 ##

优点：1：当需要将一个对象作为整体引用而不是引用对象的一个成员时，使用this，则该函数返回对调用该函数的对象的引用。

return *this;

2：可以非常明确地指出访问的是调用该函数的对象的成员，且可以在成员函数中使用与数据成员同名的形参。

class one{
    public:
        void func(int member){
           this->member = member;
        }
    private:
        int member;
    };

缺点：不必要使用，代码多余。

class two{
    public:
        void func(){
            cout<<member;//cout<<this->member;
        }
    private:
        int member;
    };

## 友元 ##

如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在内的所有成员。  
**友元类**  
若在A类中有`friend class B;`  
B类可以访问A类所有权限的成员  
**友元成员函数**  
若在A类中有`friend void B::ItsFunction(Function's Parameter);`  
B中的ItsFunction函数可以访问A类的所有权限成员  
**声明友元函数对类的定义顺序的要求**

①首先定义Window\_mgr类，其中声明clear函数，但是不能定义它。在clear使用Screen的成员之前必须先声明Screen  
②接下来定义Screen，包括对于clear的友元声明。  
③最后定义clear，此时它才可以使用Screen的成员。

using namespace std;//这段代码用来练习如何声明友元函数
    class Window_mgr {
       //但经过编译执行并不能正确地通过Window_mgr对象将某个screen对象清空（初始化字符），是由于类的定义顺序问题
    
    public:
        using ScreenIndex = vector<Screen>::size_type;
        void clear(size_t);
    private:
        vector<Screen> screens{ Screen(24,80,' ') };
    };
    class Screen {
        //friend class Window_mgr;
    
        friend void Window_mgr::clear(size_t);
    public:
        using pos = string::size_type;
        Screen() = default;
        Screen(pos wd, pos ht, char c) :height(ht), width(wd), contents(ht*wd, c) {}
        Screen(pos wd, pos ht) :height(ht), width(wd), contents(ht*wd, NULL) {}
        pos &getcursor() { return cursor; }
        char get() const { return contents[cursor]; }
        char get(pos r, pos c) { return contents[r*width + c]; }
        Screen &move(pos r, pos c) { cursor = ((r-1)*width + (c-1)); return *this; }
        Screen &set(char letter) { contents[cursor] = letter; return *this; }
        Screen &display(ostream &out) { do_display(out); return *this; }
        const Screen &display(ostream &out) const { do_display(out); return *this; }
    private:
        pos cursor{ 0 };
        pos height{ 0 }, width{ 0 };
        string contents;
        void do_display(ostream &out) const {
            for (pos index = 0; index != height * width; ++index) {
                if (index%width == 0)out << endl;
                out << contents[index] << " ";
            }
        }
    };
    
    
    void Window_mgr::clear(size_t i) {
        Screen &s = screens[i];
        s.contents = string(s.width*s.height, ' ');
    }
    int main(int *argc, char *argv) {
    
    
        return 0;
    }

**下面这段代码可以正确地通过Window\_mgr对象将6x6字符都是n的screen对象归零/初始化（都变成星），因为没有用友元函数用的是友元类**

using namespace std;
    class Screen {
        friend class Window_mgr;
        //friend void Window_mgr::clear(size_t);
    public:
        using pos = string::size_type;
        Screen() = default;
        Screen(pos wd, pos ht, char c) :height(ht), width(wd), contents(ht*wd, c) {}
        Screen(pos wd, pos ht) :height(ht), width(wd), contents(ht*wd, NULL) {}
        pos &getcursor() { return cursor; }
        char get() const { return contents[cursor]; }
        char get(pos r, pos c) { return contents[r*width + c]; }
        Screen &move(pos r, pos c) { cursor = ((r-1)*width + (c-1)); return *this; }
        Screen &set(char letter) { contents[cursor] = letter; return *this; }
        Screen &display(ostream &out) { do_display(out); return *this; }
        const Screen &display(ostream &out) const { do_display(out); return *this; }
    private:
        pos cursor{ 0 };
        pos height{ 0 }, width{ 0 };
        string contents;
        void do_display(ostream &out) const {
            for (pos index = 0; index != height * width; ++index) {
                if (index%width == 0)out << endl;
                out << contents[index] << " ";
            }
        }
    };
    
    class Window_mgr {
    
    public:
        using ScreenIndex = vector<Screen>::size_type;
        void clear(size_t);
        Screen &getScr(ScreenIndex i) { return screens[i]; }
        void addScr(Screen scr) { screens.push_back(scr); }
    private:
        vector<Screen> screens{};
    };
    
    void Window_mgr::clear(size_t i) {
        Screen &s = screens[i];
        s.contents = string(s.width*s.height, '*');
    }
    int main(int *argc, char *argv) {
        Window_mgr Manager;
        Screen scr0(6,6,'n');
        Manager.addScr(scr0);
        Manager.getScr(0).display(cout);
        cout << endl;
        Manager.clear(0);
        Manager.getScr(0).display(cout);
        cout << endl;
        return 0;
    }

**其他注意事项**  
友元关系不具有传递性，每个类负责控制自己的友元类或友元函数。  
对于要将一组重载函数设定为友元，对于每一个不同参数的版本都要分别声明。  
在类内声明的友元必须在类内或者类外进行定义之后才可以使用。

## 关于Employee的类 ##

#include"stdafx.h"
    #include<iostream>
    #include<string>
    #include<vector>
    #include<windows.h>
    using namespace std;
    class Employee {
    private:
        const string Name;
        unsigned Age;
        const float BodyHeight;
        float Weight;
        const string MainSkill;
        string SecondSkill;
        unsigned salary;
        string character;
        float WorkEffect;
    public:
        Employee(string name, unsigned age, float height, float weight,string main) :Name(name), Age(age), BodyHeight(height), Weight(weight),MainSkill(main) {
            cout << name << "的次级能力: ";cin >> SecondSkill;
            cout << name << "的目前薪水: "; cin >> salary;
            cout << name << "的性格描述: "; cin >> character;
            cout << name << "的工作贡献评分: "; cin >> WorkEffect;
        }
        void DisplayInfo() {
            cout << "\n姓名: " << Name;
            cout << "\n年龄: " << Age;
            cout << "\n身高: " << BodyHeight;
            cout << "\n体重: " << Weight;
            cout << "\n主要技能: " << MainSkill;
            cout << "\n次要技能: " << SecondSkill;
            cout << "\n目前薪水: " << salary;
            cout << "\n性格描述: " << character;
            cout << "\n工作贡献评分: " << WorkEffect<<endl;
        }
    };
    int main(int* argc, char *argv) {
        unsigned EmployeeCount;
        cout << "共有几位员工等待输入? "; cin >> EmployeeCount;
        vector<Employee> EmployeesVec{};
        string tempname,tempmain; unsigned tempage; float tempheight, tempweight;
        for (unsigned i = 1; i <= EmployeeCount;i++) {
            system("cls");
    
            cout << "输入第" << i << "位员工的姓名: "; cin >> tempname;
            cout << tempname << "的年龄: "; cin >> tempage;
            cout << tempname << "的身高: "; cin >> tempheight;
            cout << tempname << "的体重: "; cin >> tempweight;
            cout << tempname << "的主要技能: "; cin >> tempmain;
            Employee tempEmployee(tempname,tempage,tempheight,tempweight,tempmain);
            EmployeesVec.push_back(tempEmployee);
        }
        cout << EmployeeCount << "位员工的信息录入完成。";
        char choice;
        cout << "是否输出所有员工信息？Y/N";
        if (cin >> choice) {
            switch (choice)
            {
            case 'y':
            case 'Y': {
                for (unsigned i = 0; i != EmployeeCount; i++) {
                    EmployeesVec[i].DisplayInfo();
                }
                break;
            }
            default:
                break;
            }
        }
        return 0;
    }