C++特殊成员

Posted 皓月肥波

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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;

以上是关于C++特殊成员的主要内容,如果未能解决你的问题,请参考以下文章

C++特殊成员

C++知识分享:C++类特殊成员函数

[分享]C++基础十一-类的特殊成员

[分享]C++基础十一-类的特殊成员

[分享]C++基础十一-类的特殊成员

[分享]C++基础十一-类的特殊成员