C++第七章：类

类的用户是程序员，而不是最终的用户。
定义在类内部的函数都是隐式的内联函数。
类中成员变量的声明顺序，决定了成员变量的初始化顺序。

成员函数可以定义在类内部也可以定义在类外部

#include<bits/stdc++.h>
using namespace std;
struct temple{
    void print(string x);
    string num,name;
};
void temple::print(string x){cout<<x<<endl;}

int main(){
    temple a;
    a.num="这是一个struct类";
    a.print(a.num);
    return 0;
}
//在类的外部定义函数，必须包含它所属的类名

const 函数

在函数括号后加一个const说明这个函数是一个只读函数，不会修改任何数据。是一个常量函数。this是一个常量指针，总是指向这个对象，任何对类成员的直接访问都被看做this的隐式引用。
默认情况下，this的类型是指向 类类型的非常量版本的 常量指针。
声明const常量函数的作用是将这个指针转换为常量指针。

返回一个函数

#include<bits/stdc++.h>
using namespace std;
struct Node{
  int a,b;
  Node re(){   return *this;}//返回的是一个引用，建立一个临时变量，然后拷贝给目标对象，返回的是右值
}a;
int main(){
  a.a=1;
  (a.re()).a=2;//报错：将临时变量作为一个左值
  cout<<a.a<<endl;
}

构造函数

struct Node{
    Node()=default;//我们不仅需要别的构造函数，同时也需要默认的构造函数。default的意思就是默认的合成构造函数
    Node(int x1,string s):tool1(x1),tool2(s),sum(3){};
    int tool1,sum;
    string tool2;
};

class 和 struct的区别。

如果使用struct，在第一个访问说明符出现之前的成员是public的，相反，如果使用class，在第一个访问说明符之前出现的成员是private的。

友元

既然类有私有成员变量，那么如果访问类的私有成员呢？
方法是设立友元、

class Node{
    friend void print(Node x);这只是权限说明，并不声明.如果希望类的用户调用某个友元函数，还要再声明一下。
    int pre;
    public :
        Node(int x):pre(x),mid(x),las(mid){};

        int mid;
    private:
        int las;
};
void print(Node a){
    cout<<a.las;
}
int main(){
    Node a=Node(444);
    print(a);
}

mutable

#include<bits/stdc++.h>
using namespace std;
class Node{
    public :
        void member()const;
        void prin(){ cout<<counts;}//mutable,如果希望某个成员变量能够在const函数中进行修改，那么可以在这个变量定义之前加上mutable
    private:    mutable size_t counts;
};
void Node::member() const { counts++; }
int main(){
    Node a;a.member();a.member();
    a.prin();
    return 0;
}

前向声明

#include<bits/stdc++.h>
using namespace std;
class Node;//前向声明：先声明后定义的类型
Node * p;//在定义之前是一种不完全类型。只能在非常有限的情况中使用。引用或者指针，
class Node{int a,b;};//定义
int main(){}

令成员函数作为友元

#include<string>
#include<iostream>
using namespace std;

//令成员函数作为友元
//首先定声明友元函数，但是不能声明
//然后声明友元
//然后定义友元函数
class B{
public :
    void clear();
};
class A{
    friend void B::clear();
public :
    void prin(){
        cout<<a<<endl;
    }
private:
    int a;
};
void B::clear(){
    A tem;
    tem.a=5;
}

int main(){
    A a;
    B b;
    b.clear();
}

友元函数作用域：
友元函数声明为友元 和声明为函数 是不一样的，friend只是声明权限。如下：

#include<bits/stdc++.h>
using namespace std;
struct Node{
    friend void f();//定义一个友元函数
//    Node(){f();}//错误f没有被声明
    void g();
    void h();
};
//void Node::g(){f(); }//错误：f仍旧没有被声明
void f(){}
void Node::h(){f();}//正确
int main(){
    return 0;
}

名字查找：

• 在普桶程序中找声明语句
  • 首选在名字所在的块中查找，如果这个块（仅仅考虑使用之前出现的声明）没有找到，那么在外层作用域中找，如果还没有找到，就报错
• 成员函数中
  • 首选在名字所在的函数中查找，如果这个函数（仅仅考虑使用之前出现的声明）没有找到， 则在类中继续查找。如果还没有找到，就在成员函数定义之前的作用域中继续查找。类作用域之后，也在类作用域之外进行查找

委托构造函数

顾名思义：将自己的构造任务委托给别人

class Node{
    Node(int x,int y):a(x),b(x){};
    Node():Node(0,0){};
    public :
    private:
    int a,b;
};

隐式类类型转换

	#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
   int a;
   public :
       void deal(Node a){};
       Node(int a):a(a){}
       Node()=default;
};
int main(){
   Node a;
   a.deal(5);//这里本来期望收到一个Node的参数，但是收到了一个int，发生了隐式类类型转换
   return 0;
}

explicit

“可以用 单个形参来调用 的构造函数定义了从 形参类型 到 该类类型 的一个隐式转换。”
在隐式类类型转换中并不是只能有一个参数可以有多个参数，但是这些参数都是默认实参的。

excplict 抑制了隐式类类型转换
#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
    int a;
    public :
        void deal(Node a){};
        explicit Node(int a):a(a){}
        Node()=default;
};
int main(){
    Node a;
    a.deal(5);//报错，explicit抑制了隐式类类型转换
    return 0;
}

聚合类：

聚合定义为：
数组、没有以下内容的类、结构和联合：
构造函数、私有或受保护的成员、基类、虚函数

#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
    public:
    int a;
    int b;
};
int main(){
    Node a={1,2};
    return 0;
}

初探字面值常量类

数据成员必须是字面值类型
类必须至少包含一个constexpr函数，
如果类内有初始值，则必须是constexpr，如果某种成员有自己的类类型，则这个* 成员必须有自己的constexpr构造函数。
必须使用析构函数的默认定义，该成员负责销毁类的对象。

constexpr函数：所有形参和返回值都是字面值类型，有且只有一个return类型。
constexpr类的构造函数可以=default，构造函数体一般是空的，

静态成员static。

必须再类的外部进行初始化。

#include<bits/stdc++.h>
using namespace std;
class Account{
public:
     void calculate(){
         amount += amount * interestRate;
     }

     static double rate(){
         return interestRate;
     }

     static void rate(double newrate);

private:
     std::string owner;
     double amount;
     static double interestRate;
     static double initRate();
};
double Account::interestRate=0;//必须在类的外部定义和初始化每个成员。
void Account::rate(double newrate){
    interestRate=newrate;
}
int main(){
    double r=Account::rate();
    return 0;
}

如果成员变量是字面值常量类型的constexpr，就可以它提供const整数类型的类内初始值，不过要求静态成员必须是字面值常量类

#include<bits/stdc++.h>
using namespace std;
class Account{
public :
private:
    static constexpr int period=30;//只有声明没有定义，可以用作数值。但是引用等需要在类外定义
};
int main(){

}

#include<bits/stdc++.h>
using namespace std;
class Account{
public :
private:
    static constexpr int period=30;//
};
constexpr int Account::period;//初始值再类内的定义
int main(){
}

static成员可以用作默认形参，也可以是不完全类型。

#include<bits/stdc++.h>
using namespace std;
struct Bar{
public :
    void change(Bar = bar){};//静态成员可以用作默认形参
private:
    static Bar bar;//静态成员可以是不完全类型（即没有被完整定义的类型）
    Bar* bbar;
//    Bar bbbar;//报错，数据类型不能是不完全类型
};
int main(){
}