189 8069 5689

C++中this指针、静态成员、常量成员函数的示例分析

这篇文章主要为大家展示了“C++中this指针、静态成员、常量成员函数的示例分析”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“C++中this指针、静态成员、常量成员函数的示例分析”这篇文章吧。

十年的平坝网站建设经验,针对设计、前端、开发、售后、文案、推广等六对一服务,响应快,48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同,自动调整平坝建站的显示方式,使网站能够适用不同显示终端,在浏览器中调整网站的宽度,无论在任何一种浏览器上浏览网站,都能展现优雅布局与设计,从而大程度地提升浏览体验。创新互联从事“平坝网站设计”,“平坝网站推广”以来,每个客户项目都认真落实执行。

一、this指针

1、C++程序到C程序的翻译

class CCar {                          struct CCar {
    public:                                int price;
    int price;                        };
    void SetPrice(int p);             void SetPrice(struct CCar * this,int p){
};                                        this->price = p;
void CCar::SetPrice(int p){           }
    price = p; //this->price = p;
}                                     int main() {
int main(){                               struct CCar car;
    CCar car;                             SetPrice( & car,20000);
    car.SetPrice(20000);                  return 0;
    return 0;                         }
}

2、this指针作用:非静态成员函数中可以直接使用this来代表指向该函数作用的对象的指针

3、this指针和静态成员函数:静态成员函数并不具体作用与某个对象,所以静态成员函数中不能使用 this 指针

二、静态成员

  • 静态成员:在说明前面加了static关键字的成员。

  • 普通成员变量每个对象有各自的一份,而静态成员变量一共就一份,为所有对象共享,sizeof 运算符不会计算静态成员变量。

  • 普通成员函数必须具体作用于某个对象,而静态成员函数并不具体作用于某个对象,不需要通过对象就能访问。

class CRectangle{
    private:
        int w, h;
        static int nTotalArea; // 静态成员变量
    public:
        CRectangle(int w_,int h_);
        ~CRectangle();
        static void PrintTotal(); // 静态成员函数
};

1、访问静态成员的方法:

  • 类名::成员名        CRectangle::PrintTotal();

  • 对象名.成员名     CRectangle r; r.PrintTotal();

  • 指针->成员名       CRectangle * p = &r; p->PrintTotal();

  • 引用.成员名         CRectangle & ref = r; int n = ref.nTotalNumber;

2、注意事项:

  • 静态成员变量本质上是全局变量,哪怕一个对象都不存在,类的静态成员变量也存在

  • 必须在定义类的文件中对静态成员变量进行一次说明或初始化。否则编译能通过,链接不能通过

  • 在静态成员函数中,不能访问非静态成员变量,也不能调用非静态成员函数

三、成员对象和封闭类

1、定义:有成员对象的类叫 封闭(enclosing)类

class CTyre{             // 轮胎类
    private:
        int radius;      // 半径
        int width;       // 宽度
    public:
        CTyre(int r,int w):radius(r),width(w) { }
};
class CEngine{           // 引擎类
};
class CCar {             // 汽车类
    private:
        int price;       // 价格
        CTyre tyre;
        CEngine engine;
    public:
        CCar(int p,int tr,int tw );
};
CCar::CCar(int p,int tr,int w):price(p),tyre(tr, w){};
int main(){
    CCar car(20000,17,225);
    return 0;
}

上例中,如果 CCar类不定义构造函数, 则下面的语句会编译出错:CCar car;因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题,用默认构造函数即可。任何生成封闭类对象的语句,都要让编译器明白,对象中的成员对象,是如何初始化的。具体的做法就是:通过封闭类的构造函数的初始化列表。

2、封闭类构造函数和析构函数的执行顺序

  • 封闭类对象生成时,先执行所有对象成员的构造函数,然后才执行封闭类的构造函数。

  • 对象成员的构造函数调用次序和对象成员在类中的说明次序一致,与它们在成员初始化列表中出现的次序无关。

  • 当封闭类的对象消亡时,先执行封闭类的析构函数,然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

class CTyre {
    public:
        CTyre() { cout << "CTyre contructor" << endl; }
        ~CTyre() { cout << "CTyre destructor" << endl; }
};
class CEngine {
    public:
        CEngine() { cout << "CEngine contructor" << endl; }
        ~CEngine() { cout << "CEngine destructor" << endl; }
};
class CCar {
    private:
        CEngine engine;
        CTyre tyre;
    public:
        CCar( ) { cout << “CCar contructor” << endl; }
        ~CCar() { cout << "CCar destructor" << endl; }
};
int main(){
    CCar car;
    return 0;
}
//输出结果:
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor

四、友元(friends)

1、友元分为友元函数和友元类两种

(1)友元函数 :  一个类的友元函数可以访问该类的私有成员

class CCar ;     //提前声明 CCar 类,以便后面的CDriver 类使用
class CDriver{
    public:
    void ModifyCar( CCar * pCar) ;         // 改装汽车
};
class CCar{
    private:
        int price;
        friend int MostExpensiveCar( CCar cars[], int total); // 声明友元
        friend void CDriver::ModifyCar(CCar * pCar);     // 声明友元,可包括构造、析构函数
};
void CDriver::ModifyCar( CCar * pCar){
    pCar->price += 1000;                        // 汽车改装后价值增加
}
int MostExpensiveCar( CCar cars[],int total){   // 求最贵汽车的价格                           
    int tmpMax = -1;
    for( int i = 0;i < total; ++i )
    if( cars[i].price > tmpMax)
    tmpMax = cars[i].price;
    return tmpMax;
}

(2)友元类 : 如果A 是B的友元类,那么A 的成员函数可以访问B的私有成员,友元类之间的关系不能传递,不能继承

class B{
    friend class A;      // 声明A为友元类
};

五、常量成员函数

1、作用:如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加 const关键字

  • 在类的成员函数说明后面可以加const关键字,则该成员函数成为常量成员函数。

  • 常量成员函数内部不能改变属性的值,也不能调用非常量成员函数

  • 在定义常量成员函数和声明常量成员函数时都应该使用const 关键字

class Sample {
    private :
        int value;
    public:
        Sample() { }
        void SetValue() {  }
};
const Sample Obj;  //  常量对象
Obj.SetValue ();   //错误,常量对象只能使用构造函数、析构函数和有const说明的函数(常量方法)

2、常量成员函数的重载:两个函数,名字和参数表都一样,但是一个是const,一个不是,算重载

3、mutable成员变量:

(1)作用:mutable突破const的限制而设置,被mutable修饰的变量将永远处于可变的转态,即使在一个const函数中。

(2)应用:如果类的成员函数不会改变对象的状态,那么一般会声明成const。但是,有些时候,需要在const的函数里面修改一些跟类状态无关的数据成员,那么这些数据成员就应该被mutable来修饰。

class CTest{
    public:
        bool GetData() const{
            m_n1++;
            return m_b2;
        }
    private:
        mutable int m_n1;
        bool m_b2;
};

以上是“C++中this指针、静态成员、常量成员函数的示例分析”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注创新互联行业资讯频道!


文章标题:C++中this指针、静态成员、常量成员函数的示例分析
文章路径:http://cdxtjz.cn/article/jjspoi.html

其他资讯