C++复习之——类，运算符重载，友元

1.定义在类内部的函数，是隐式的内联函数；inline成员函数应该与相应的类定义在头文件中

2.所有成员都必须在类内声明，但是函数体定义可以是在类内也可以实在类外；但是类外部的定义，就必须包含它的类名::

3.如果我们给类定义了一个构造函数，那么编译器将不会自动为其生成默认构造函数。我们在不进行初始化而需要默认初始化的时候，就会出错。因此，只要我们为类定义了构造函数，就必须给类定义一个默认构造函数。防止出现默认初始化而出错

4.C++11中，如果要求默认的行为，可以在参数列表后添加　=defualt　来要求编译器生成构造函数

５．构造函数不应该轻易的覆盖掉类内的初始值，除非新值与原值不同。如果不能使用类内初始值，则所有构造函数都应显式的初始化内个内置类型的成员

.const在函数名前，表示的函数的返回值是常量：const func(){ ... }

const 在函数后，表示函数不能修改访问的对象：func() const { ... }

 

类的声明与定义：

最好令构造函数初始值的顺序与成员声明的顺序保持一致，而且，如果可能的话，尽量避免使用某些成员初始化其他成员。

这是一个头文件stock.h
#ifndef STOCK_H_
#define STOCK_H_
#include<string>

class Stock
{
    private:
        std:: string company;
        long shares;
        double share_val;
        double total_val;
        void set_tot() {total_val = shares * share_val; }
    public:
        Stock() = default; //默认构造函数
        Stock(const std::string &co, long n = 0, double pr = 0.0); //我们编写的构造函数
        //这里就要注意，我们直接进行了初始化。后面会讲到初始化和赋值的区别及影响
        //要有直接初始化的好习惯
        ~Stock();//析构函数
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show() const;       
}
#endif


函数体文件stock.cpp

Stock:: Stock()
{
    std::cout<<"default called\n";
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}

Stock:: Stock(const std::string &co, long n, double pr)
{
    company = co;
    if(n<0)
    {
      std::cout<<"不能为负数"；
      shares = 0;
    }
    else
        shares = n;
    share_val = pr;
    set_tot();
}

void Stock::show() const
{
    //bulabula~~
}

然后可以在cpp的实现文件里写函数体等等。

－－－－－

访问控制与封装

定义在public说明符之后的成员，可以被整个程序访问，public成员定义类的接口

定义在private说明符之后的成员，只能被类的成员函数访问。封装隐藏了类的实现细节

－－－－－

struct和class的区别

我们可以使用两个关键字的任何一个定义类，唯一一点区别就是，两者的默认访问权限不一样

类可以在它的第一个访问说明符之前定义成员，那么这些成员属于private还是public呢？

如果我们使用struct定义类，则这些成员属于public

如果用class，则属于private

－－－－－

－－－－－

友元

当非该类的成员函数想要访问类的非公有成员时，使用友元

即，在类的定义内，添加该函数声明，并在函数声明前添加关键字friend

一般在类的最开始或末尾集中添加友元

-----------------------------------------------------------------------------------------------

类内友元的声明不能算作函数的声明，要想使用函数，还得在外面声明该函数

-----------------------------------------------------------------------------------------------

但是，对于类的使用者，如何知道友元的存在呢？

所以，一般，我们通常把友元的声明与类本身放置在同一个头文件中

因为它不是成员函数，因此不要使用 Time:: 限定符。 另外不要在定义中使用关键字friend。
 

－－－－－

区别注意区分
 

Stock stock1("NanoSmart", 12, 20.0);// 这是直接初始化

Stock stock2 = Stock("Boffo", 2, 2.0);//初始化。这里有两种情况：1，同上；2，先创建一个临时变量用来存储boffo等的值，然后将值赋值给stock2，随后就析构该临时变量

stock1 = Stock("Nifty", 10, 50.0);//这里并不是初始化，而是赋值。创建临时变量用来存储nifty，然后将值赋值给stock1，随后就析构该临时变量

//因此，当进行赋值时，如果能直接初始化，就要初始化。会节省创建临时变量，然后赋值的过程和资源。


Stock *p = new Stock("Bulabula" ,6 ,6.6);
//创建一个Stock，并将其初始化，将该对象的地址赋值给p指针。

－－－－－

重载成员函数

在参数数量和参数类型上有区别即可

不允许两个函数除了返回类型不同外，其他都相同，会报错

－－－－－

可变数据成员

mutable关键字

当一个成员是一个可变成员，mutable a;

则，即使是被void func() const{ ++a; }　函数访问

则该变量在函数内也是可变的

就意味着，const对可变数据成员失效

－－－－－

友元再探

一个类也可以成为另一个类的友元

友元没有传递性：即Ａ是有友元Ｂ和Ｃ，但是ＢＣ之间并没有友元关系

－－－－－

构造函数再探

class constref
{
public:
    constref(int ii);
private:
    int i;
    const int ci;
    int &ri;    
};

//错误的，因为const和引用，必须初始化
constref::constref(int ii)
{
    i = ii;
    ci = ii;
    ri = i;
}

//正确方法,显示的初始化const和引用
constref::constref(int ii): i(ii),ci(ii),ri(i){}
//构造函数中，并没有这些参数，但是我们可以通过:开头，作为分隔，来初始化

初始化顺序：在类的定义中，谁先出现，谁就先初始化

如下，构造函数中，我们用val初始化j，用j初始化i

但是，我们是先初始化ｉ，因为ｉ先出现在定义中，

即先用j初始化i，j未定义，报错

－－－－－

隐式的类类型转换

如果有一个类，stonewt

它有一个构造函数stonewt(double lbs);

stonewt mycat;
mycat = 19.6;
//在这个过程中，首先
//先创建了一个临时stonewt的对象，并用19.6对其进行了初始化
//然后将该临时对象的内容复制给mycat
//中间发生了隐式的类型转换double->mycat

使用explicit关键字可以阻止隐式的类型转换

explicit stonewt(double lbs);
stonewt mycat;
mycat = 19.6;//错误，隐式的类型转换被禁止了
mycat = stonewt(19.6);//显式转换可行
mycat = (stonewt) 19.6;//可行

－－－－－

类的静态成员

可以是常量，引用，指针等

类的静态成员不属于类的某个对象

但是我们扔可以使用类的对象、引用或者指针来访问静态成员

－－－－－

因为静态数据成员不属于类的任何一个对象，所以他们并不是在创建类的对象时被定义的

这意味着他们不是由类的构造函数初始化的

一般来说，我们不在一个类内初始化静态成员，想法内的必须在类的外部定义和初始化静态成员

静态成员定义在任何函数之外，一旦被定义，将存在与程序的整个生命周期中

－－－－－

－－－－－－－－－－－－－－－－

如果想给类的private变量直接赋值

class B
{
    private:
        const int Months = 12;
        double costs[Months];
        .....
}//这是错误的，因为声明类只是描述了对象的形式，并没有创建对象，此时Months是没有存储值的空间的


class B
{
    private:
        static const int Months = 12;
        double costs[Months];
        .....
}//正确

8. 运算符重载

.h
class Time
{
private:
    int hours;
    int minutes;

public:
    Time();
    Time(int h, int m = 0);
    void addm(int m);
    void addh(int h);

    //重载的+，-，*三个操作运算符.函数后的const表示不对读取的变量进行修改
    Time operator+(const Time &t) const;
    Time operator-(const Time &t) const;
    Time operator*(const Time &t) const;
    void show() const;
}

.cpp
//第一个Time是函数的返回类型，第二个Time表示，函数实在Time类中定义的
Time Time::operator+(const Time &t) const
{
    Time Sum;
    Sum.minutes = (minutes + t.minutes)%60;
    Sum.hours = hours + (minutes + t.minutes)/60;
    return Sum;
}


Time Time::operator-(const Time &t) const
{
    Time Diff;
    int one, two;
    one = hours*60 + minutes;
    two = t.hours*60 + t.minutes;
    Diff.minutes = (one - two)%60;
    Diff.hours = (one - two)/60;
    return Diff;
    
}

//等等.....

9.友元（友元函数，友元类，友元成员函数）

友元函数：非成员函数可以访问类的私有成员。

首先说明，对于函数运算符的重载

A = B * 10；  //其实就等于 A = B.operator*（10）
A = 10 * B； //但是，并没有A = 10.operator*（B），因此，重载只能先类后数，不能先数后类

 

创建友元：

(1)将原型放在类声明中，并在原型声明前加上关键字friend。

friend Time operator* (double m, const Time & t);

a.虽然函数实在类声明中声明的，但是它不是类的成员函数，因此不能用成员运算符来调用；

b.虽然不是成员函数，但是它与成员函数的访问权限相同。

 

(2)编写函数定义，因为它不是成员函数，因此不要使用 Time:: 限定符。 另外不要在定义中使用关键字friend。
 

Time operator* (double m , const Time &t )

{
    Time result;
    long totalminutes = t.hours * m + 60  + t.minutes * m;
    result.minutes = totalminutes %60;
    result.minutes = totalmunites/60;
    return result;
}

 

10.重载<<运算符

我们想要直接cout<<Time;

如果按照传统的Time operator<<(ostream &s)

那么我们只能Time<<cout;，因为我们定义的是Time的成员，同上B*10可以，但是10*B不行。

因此我们可以定义为友元：
 

void operator<<(ostream &os, const Time & t)

{    
    os << t.hours <<"hours, "<< t.minutes << "minutes";
}

这样我们就可以使用cout<<Time；
但是，我们也只能这么使用。
而无法使用cout<<Time1 << Time2;
因为我们平常使用的cout，返回的都是ostream对象
因此我们需要如此修改


ostream & operator<<(ostream &os, const Time & t)
{
    os << t.hours <<"hours, "<< t.minutes << "minutes";
    return os;
}

此时我们就可以使用cout<<Time1 << Time2;

 

 

11.成员函数和非成员函数的区别：

Time operator+(const Time & t) const;
//通过成员函数，this指针，隐式的传递了一个参数，另一个参数通过t传递

friend Time operator+(const Time & t1, const Time & t2);
//两个参数通过t1,t2传递