c++Primer第七章：类

爱被打了一巴掌 2022-11-15 12:25 252阅读 0赞

### 目录 ###

*  代码
 *   *  建议
     *  问题以及学习内容
     *   *  1.类名和define 重名
         *  2.友元类分两个文件写
         *  3.友元函数-非成员函数
         *  4.友元函数-成员函数
     *  代码内容
     *   *  1.友元类
         *  2.基础类学习
         *  3.静态成员与静态函数

# 代码 #

## 建议 ##

1.返回已经存在的数据，尽量用引用类型，减少拷贝。

2.函数前const表示返回的是常量，后const表示不会对类中方数据进行改变，当作只读函数就行。

3.函数传参的时候尽量传引用，如果没有对数据进行修改，就加个const。

4.this指向当前对象，有时候为了连续调用即点连点会使用，具体看基础类学习。

5.使用IO类为参数，由于IO类型不可拷贝，所以使用的是引用参数，返回的也是引用类型，保证输出的流对象是一个对象，即传进来是谁，返回的也是谁c++p270。

5.运算符重载问题，使用了IO流的都是IO类调用本类的数据或者函数，所以必须是友元函数，否则没有权限。

6.有其他构造函数了也要写默认构造函数，复合类或者嵌套类有时候编译器不能自动合成默认构造函数。

7.const成员函数可以改变mutable数据成员。

8.const对象只能调用const成员，但是const对象的数据不能改变，所以使用前后两个const进行函数重载。

9.委托构造函数，可以根据输入的不同调用不同的构造函数。

10.explicit防止构造函数的隐式转换，例如只给某成员函数传入string，函数参数类型是class，结果自动调用了相应的构造函数，将类型进行了转换。explicit函数只能直接初始化。

## 问题以及学习内容 ##

### 1.类名和define 重名 ###

![在这里插入图片描述][20210401134755382.png]  
友元，相当于谁被用，谁写friend

### 2.友元类分两个文件写 ###

class A 是 class B 的友元类，即class A可以使用class B 中数据  
在 A.h 中，先声明class B,

class B;
    class A{ 
    	private:...
    	public:...
    }

在B.h中

#include"A.h"
    class B{ 
    	private:...
    	public:
    	friend class A
    	...
    }

### 3.友元函数-非成员函数 ###

class A{ 
    	public:
    	friend void show(A &)；
    	private:
    }
    void show(A &a){ 
    ...
    }

### 4.友元函数-成员函数 ###

class A  
该类中使用class B的数据

class B
    class A{ 
    	public:
    	void show(B &);
    	private: 
    }

class B

class B{ 
    	public:
    	friend void A::show(B &);
    }
    void A::show(B &){ };

## 代码内容 ##

### 1.友元类 ###

class A.h

#ifndef WINDOW_MGR
    #define WINDOW_MGR
    #include<iostream>
    #include<vector>
    //友元类
    #include"Screen.h"
    using namespace std;
    class Screen;
    class Window_mgr
    { 
    private:
        //默认情况下，一个Window_mgr包含一个全是‘*’的Screen
        vector<Screen> screens{ Screen(5,5,'*')};
    public:
        typedef vector<Screen>::size_type ScreenIndex;
        //指定编号的Screen清空
        void clear(ScreenIndex); 
        //输出屏幕
        void show();
        //增加屏幕
        ScreenIndex addScreen(const Screen&);
    };
    
    #endif

class A.cpp

#include"Window_mgr.h"
    //调用了非本类的函数
    void Window_mgr::show(){ 
        for(auto temp:screens)
            temp.dispaly(cout);
    }
    
    Window_mgr::ScreenIndex Window_mgr::addScreen(const Screen &s){ 
        screens.push_back(s);
        //返回其编号
        return screens.size()-1;
    }
    
    void Window_mgr::clear(ScreenIndex i){ 
        Screen &s = screens[i];
        cout<<"clear: "<<s.height<<" "<<s.width<<endl;
        s.contents = string(s.height*s.width,' ');
    }

class B.h

#ifndef SCREEN
    #define SCREEN
    #include<iostream>
    #include<string>
    #include"windows.h"
    //#include"Window_mgr.h"
    using namespace std;
    //别名
    typedef string::size_type pos;
    class Screen
    { 
    private:
        //光标所在位置
        pos cursor = 0,height = 0,width = 0;
        //光标所在位置的字符
        string contents;
        mutable size_t access_ctr;
        //输出函数
        void do_display(ostream &os) const{ 
            os<<contents;
        }
    public:
        //声明友元类，即可以调用Screen类中的函数
        friend class Window_mgr;
        Screen() = default;
        //给定屏幕的尺寸，声明一个一维数组，用于存放字符
        Screen(pos ht,pos wd, char c):height(ht),width(wd),contents(ht*wd,c){ };
        //隐式内联，获取光标处的字符
        char get() const{ return contents[cursor];}
        //显式内联，函数重载 获取给定处的字符
        char get(pos ht,pos wd) const;
        //之后设置为内联，移动光标
        inline Screen &move(pos r,pos c);
        //计数
        void some_number() const;
        //设置光标所在的字符
        Screen &set(char);
        //设置其他任意位置的字符
        Screen &set(pos,pos,char);
        //打印 非常量
        Screen &dispaly(ostream &os);
        //打印 常量
        const Screen &display(ostream &os) const; 
    };
    
    //r行 c列
    //定义处设置内联，把光标移至指定位置
    inline Screen& Screen::move(pos r,pos c){ 
        pos row = r * width;
        cursor = row + c;
        //以左值的方式返回
        return *this;
    } 
    #endif

class B.cpp

#include"Screen.h"
    
    //返回给定列的字符 
    char Screen::get(pos r,pos c) const{ 
        pos row = r * width;
        return contents[row+c];
    }
    
    void Screen::some_number() const{ 
        ++access_ctr;
    }
    
    Screen& Screen::set(char c){ 
        contents[cursor] = c;
        return *this;
    }
    Screen& Screen::set(pos r,pos col,char ch){ 
        contents[r*width+col] = ch;
        return *this;
    }
    Screen & Screen::dispaly(ostream &os){ 
        do_display(os);
        return *this;
    }
    const Screen& Screen::display(ostream &os) const{ 
        do_display(os);return *this;
    }

main.cpp使用

Screen myScreen(5,5,'x');
    myScreen.move(4,0).set('#').dispaly(cout);
    cout<<endl;
    myScreen.dispaly(cout);
    cout<<endl;
    
    cout<<"Window"<<endl;
    Window_mgr Screens;
    int count = Screens.addScreen(myScreen);
    Screens.show();
    cout<<"myscreen number "<<count <<endl;

结果  
![结果][20210402165133830.png]

### 2.基础类学习 ###

class sales\_data.h

#ifndef SALA_DATA
    #define SALA_DATA
    #include<iostream>
    #include<string>
    using namespace std;
    class sales_data
    { 
    private:
        string bookno;//书号
        double units_sold;//销售的册数
        double price;
        double revenue;//总销售额
        double average;
    
    public:
        // 无参构造函数
        sales_data();
        //sales_data() = deflaut 默认构造函数;
        //有参数的构造函数
        sales_data(string b,int u,double p):bookno(b),units_sold(u),price(p){ };
        //运算符重载 友元函数,其他类调用该类中的私有数据，返回的是引用类型，必须保证是引用，否则调用构造函数，输入输出的对象不是一个，
        friend istream& operator >> (istream &,sales_data &);
        friend ostream& operator << (ostream &,sales_data &);
        friend sales_data operator + (sales_data &lhs,sales_data & rhs);
        //引用不会调用拷贝构造函数，在内存中不产生被返回值的副本
        sales_data& operator = (const sales_data &);
        friend bool operator == (sales_data &,sales_data &);
        sales_data &operator += (const sales_data &);
        double avg_price();
        //声明isbn函数，返回书籍号
        string isbn() const;
        //一个combine成员函数，用于将一个sales_data对象加到另一个对象上
        sales_data& combine(const sales_data &);
        //声明sales_data类的非成员接口函数
        //一个read函数，将数据从istream读入到sales_data对象中
        friend istream & read(istream &,sales_data &);
        //一个add函数，执行两个对象的加法
        //friend sales_data add(const sales_data &, const sales_data &);
        //sales_data add(const sales_data &, const sales_data &);
    };
    sales_data add(const sales_data &, const sales_data &);
    #endif

class sales\_data.cpp

#include"Sales_data.h"
    
    // 加default 就不需要赋初始值
    sales_data::sales_data(){ 
        bookno = "null";
        units_sold = 0;
        price = 0.0;
    }
    //接下来的四个函数都是友元函数，其他类的，不需要加class的定义域
    istream& operator >>(istream &input,sales_data &s){ 
        input >> s.bookno >> s.units_sold >> s.price;
        if(input){ 
            s.revenue = s.units_sold * s.price;
        }
        return input;
    }
    
    ostream& operator << (ostream &output,sales_data &s){ 
        output << s.bookno <<" "<< s.units_sold << " "<<s.revenue<<" "<<s.avg_price()<<endl;
        return output;
    }
    //返回的是函数内部的变量，需要是拷贝值
    sales_data operator + (sales_data &lhs,sales_data &rhs){ 
        sales_data ret;
        ret.bookno = lhs.bookno;
        ret.units_sold = lhs.units_sold + rhs.units_sold;
        ret.avg_price();
        return ret;
    }
    
    bool operator == (sales_data &lhs,sales_data &rhs){ 
        return lhs.units_sold == rhs.units_sold && lhs.price == rhs.price;
    }
    //重载赋值运算符 本类中声明的函数
    sales_data& sales_data::operator = (const sales_data &lhs){ 
        bookno = lhs.bookno;
        units_sold = lhs.units_sold;
        price = lhs.price;
        return *this;
    }
    
    sales_data& sales_data::operator += (const sales_data &rhs){ 
        units_sold += rhs.units_sold;
        revenue += rhs.revenue;
        return *this;
    }
    
    double sales_data::avg_price(){ 
        average = revenue / units_sold;
        return average;
    }
    
    string sales_data::isbn() const{ 
        return bookno;
    }
    //和重载的+一致，只要返回的不是该函数内部的都加引用
    sales_data &sales_data::combine(const sales_data &rhs){ 
        units_sold += rhs.units_sold;
        revenue += rhs.revenue;
        return *this;
    } 
    
    istream & read(istream &input,sales_data &rhs){ 
        input >> rhs.bookno >> rhs.units_sold >> rhs.price;
        rhs.revenue = rhs.units_sold * rhs.price;
        return input;
    }
    sales_data add(const sales_data &lhs,const sales_data &rhs){ 
        sales_data sum = lhs;
        sum.combine(rhs);
        sum.avg_price();
        return sum;
    }

### 3.静态成员与静态函数 ###

student.h

#ifndef STUDENT
    #define STUDEBT
    #include<iostream>
    using namespace std;
    class Student{ 
    public:
        Student(int n,int a,float s):num(n),age(a),score(s){ }
        void total();
        //声明静态成员函数，求取平均分，这写static，后面就不用写了
        static float average();
    private:
        int num;
        int age;
        float score;
        //计算总分
        static float sum;
        //统计人数
        static int count;
    };
    #endif

student.cpp

#include"Student.h"
    
    void Student::total(){ 
        sum += score;
        count++;
    }
    float Student::average(){ 
        return (sum/count);
    }

main.cpp

Student stu[3]={ 
            Student(1001,18,70),
            Student(1002,19,78),
            Student(1005,20,98),
        };
    int n;
    cout<<"how many students' grates? ";
    cin>>n;
    for(auto &it : stu){ 
       it.total();
    }
    cout<<"average = "<<Student::average()<<endl;

结果  
![在这里插入图片描述][20210402181721118.png]

[20210401134755382.png]: /images/20221022/bc782849346e41bc90b16b9a3c3e0228.png
[20210402165133830.png]: /images/20221022/c455abf50ff1467ebe9e35960894adac.png
[20210402181721118.png]: /images/20221022/7931f726151a48c0ba5bf41291eebd37.png