C++学习基础知识--this指针、静态成员、常量成员函数

时间2024-01-30 23:14:03发布访客分类ASP.NET浏览575

导读：收集整理的这篇文章主要介绍了C++学习基础知识--this指针、静态成员、常量成员函数，觉得挺不错的，现在分享给大家，也给大家做个参考。一、this指针1、C++程序到c程序的翻译class CCar {...

收集整理的这篇文章主要介绍了C++学习基础知识--this指针、静态成员、常量成员函数，觉得挺不错的，现在分享给大家，也给大家做个参考。一、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 contructorCTyre contructorCCar contructorCCar destructorCTyre destructorCEngine 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;
}
    ;