C++特殊成员

c++特殊成员

const成员

• const数据成员

  • const类型变量不能修改，只读数据成员

  • 类中const数据成员,只能采用初始化参数列表方式进行初始化

• const成员函数

  • 写法上const写在函数后面

  • 常成员函数不能修改数据成员，只读数据成员

  • 常成员函数可以和普通函数同时存在

    • 普通函数和常成员函数相同时，先调用普通函数

    • 普通对象可以调用常成员函数

• const对象：const修饰的对象

  • 常对象只能调用常成员函数

    #include<iostream>
    #include<string>
    using namespace std;
    class girlfriend
    {
    public:
        girlfriend(string name, int num) :num(num)  //正确
        {
            girlfriend::name = name;
            //grilfriend::num=num;      错误，const数据成员只能采用初始化参数列表的方式初始化
        }
        void print()
        {
            //num=55;                    错误不能修改，只读属性
            cout << name << "\t" << num << endl;
        }
        void print() const
        {
            
            //name = "唐昊";num=55;       常成员函数不能修改数据         
            cout << name << "\t" << num << endl;
        }
        void printData()
        {
            cout << "普通函数" << endl;
        }
    protected:
        string name;
        const int num;
    };
    int main()
    {
        girlfriend girl("谭奥", 19);
        girl.print();           //普通对象调用默认普通函数，当没有普通函数时调用常成员函数
        const girlfriend girl2("张伟", 19);
        girl2.print();          //常对象只能调用常成员函数
        //girl2.printData();    //错误
        return 0;
    }

static数据成员

static成员不属于对象，属于类的，意味着所有对象共有的，调用可以不需要对象，当然你可以用对象调用

static成员依旧受权限限定

• static数据成员

  • 必须在类外初始化，类中初始化是错误的，故不能采用初始化参数列表的方式初始化。

  • 类外初始化不需要static

• static成员函数

  • 调用非静态成员，必须指定对象

  • 静态成员函数的调用是不需要对象的

  • static写在成员函数前面即可

#include<iostream>
using namespace std;
class bo
{
public:
    bo(string name = "") :name(name)
    {
        num++;
    }
    static void print()
    {
        //cout << name << endl; // 错误，调用非静态成员必须指定对象,否则没有来源
        cout << num << endl;
    }
    static void printData(bo& bg)
    {
        cout << bg.name << endl;
        cout << num << endl;
    }
protected:
    string name;
public:
    static int num;
};
int bo::num = 20;
int main()
{
    bo::print();         //静态成员函数的调用是不需要对象的
    bo TanAo("谭奥");
    TanAo.print();
    bo::printData(TanAo);
    return 0;
}
​

友元

friend描述的关系，友元只提供一个场所，赋予对象具有打破类的权限限定

• 友元函数

  • 普通友元函数

  • 已另一个类的成员函数充当友元函数(多文档编程不会出现这个问题），顺序如下

    • B类

    • A类

    • A类的友元函数（B的成员函数）

#include<iostream>
using namespace std;
void printData();          //声明语法
class bg
{
public:
    bg(string name, int age) :name(name), age(age) {}
    void print()
    {
        cout << name << "\t" << age<<endl;
    }
    friend void printData()
    {
        //cout << name << "\t" << age; 错误友元函数不属于类不能直接访问成员
        bg bb("张维",19);
        //友元无视权限
        cout << bb.name << "\t" << bb.age<<endl;
    }
protected:
    string name="bg";
private:
    int age=20;
    friend void printData2(bg& bb);
};
void printData2(bg& bb)
{
    cout << bb.name << "\t" << bb.age << endl;
}
​
//实现B的成员函数是A的友元函数
class B
{
public:
    void printA();
    void printData();
};
class A
{
public:
    friend void B::printA();
protected:
    string name = "A";
};
void B::printA()
{
    A a;
    cout << a.name << endl;
}
void B::printData()
{
    A a;
    //cout << a.name << endl;错误，不是A的友元函数，不能突破权限限定
}
int main()
{
    printData();
    bg bb1("谭奥",19);
    bb1.print();
    printData2(bb1);
    B b;
    b.printA();
    return 0;
}

• 友元类

#include<iostream>
using namespace std;
class MM
{
    friend class GG;
public:
    MM(string name,int age):name(name),age(age){}
protected:
    string name;
    int age;
};
class GG
{
public:
    //无视权限
    void print()
    {
        MM mm("mm", 19);
        cout << mm.name << "\t" << mm.age << endl;
    }
    void printData(MM& mm)
    {
        cout << mm.name << "\t" << mm.age << endl;
    }
    MM& returnMM(MM& mm)
    {
        return mm;
    }
};
//互为友元类的写法
class A
{
    friend class B;
public:
    void printData();
protected:
    string data = "A";
};
​
class B
{
    friend class A;
public:
    void printData()
    {
        A a;
        cout << a.data << endl;
    }
protected:
    string data = "B";
};
void A::printData()
{
    B b;
    cout << b.data<< endl;
}
int main()
{
    MM mm("mm", 19);
    GG gg;
    gg.print();
    gg.printData(mm);
    gg.returnMM(mm);
    //cout << gg.returnMM(mm).name << endl;错误出了友元类没有了权限
    B b;
    b.printData();
    A a;
    a.printData();
    return 0;
}

this指针与explicit

• explict修饰构造函数使用，不让隐式转换构造

• this指针

  • 避免形参名与数据成员同名，通指对象的地址

  • 充当函数返回值，返回对象本身，用this*表示对象本身

  • 静态成员函数中是不能使用this指针

#include <iostream>
using namespace std;
class MM
{
public:
    explicit MM(int age) :age(age) {}
    void print()
    {
        cout << age << endl;
    }
protected:
    int age;
};
class GG
{
public:
    GG(string name, int age) :name(name), age(age) {}
    //普通函数不存在初始化参数列表
    void initData(string name, int age)
    {
        //类名限定 帮助计算机去识别
        GG::name = name;
        //用this指针
        this->age = age;
    }
    void print()
    {
        cout << this->name << " " << this->age << endl;
    }
    void printThis()
    {
        cout << this << endl;
    }
    GG& returnGG()
    {
        return *this;
    }
​
    static void printStatic()
    {
        GG gg("this", 19);
        cout << gg.name << "\t" << gg.age << endl;
    }
protected:
    string name;
    int age;
};
int main()
{
    //explicit 不让隐式转换构造
    //MM mm = 12;
    //MM temp = 1.33;
    MM temp(12);
    temp.print();
​
    GG gg("武汉乱披风", 20);
    gg.print();
​
    gg.initData("昊天锤", 19);
    gg.print();
​
    cout << &gg << endl;
    gg.printThis();
​
    GG boy("唐三", 21);
    cout << &boy << endl;
    boy.printThis();
​
    gg.returnGG().returnGG().returnGG().returnGG().returnGG().returnGG().print();
​
​
    GG::printStatic();
    return 0;
}