C++高级知识点说明。

 

1。常量对常量函数：  

 

#include"stdafx.h"
#include <iostream>
using namespace std;
  class Base ...{
 int  m_cc; int m_dd;
  public:
  Base() ...{
   m_cc=0;   m_dd=0;    cout << "Base constructor" << endl;
  } 
  ~Base() ...{    cout << "Base destructor" << endl;   }
   int getcc() const   ...{   return m_cc;   };  //函数1
   int getcc()   ...{   return m_cc;   }; //函数2
   Base* operator&()   ...{      return this;   };//算子1
   const Base  * operator&() const   ...{      return this;   }; //算子2
 };
 const Base *  pd1;
 int main()
 ...{
 Base dd1;
 const Base dd5;
 Base * pd2=&dd1; ;//算子1
const  Base * pd3=&dd1; ;//算子1
 pd1=&dd5; ;//算子2
 cout<<pd1->getcc()<<endl; //函数1
 Base xx=dd1;
 cout<<xx.getcc()<<endl; //函数2
 return 0;
 }

2.赋值函数注意的四个步骤：

 

 class String
  ...{
      public:
        String(const char *str = NULL); // 普通构造函数
        String(const String &other);    // 拷贝构造函数
        ~ String(void);                 // 析构函数
        String & operate =(const String &other);    // 赋值函数
      private:
        char    *m_data;                // 用于保存字符串
    };
String::String(const char *str)
...{
    if(str==NULL)
    ...{
        m_data = new char[1];
        *m_data = ‘0’;
    }   
    else
    ...{
        int length = strlen(str);
        m_data = new char[length+1];
        strcpy(m_data, str);
    }
}   
// String的析构函数
String::~String(void)
...{
    delete [] m_data;   
  // 由于m_data是内部数据类型，也可以写成 delete m_data;
}

// 拷贝构造函数
    String::String(const String &other)
    ...{   
      // 允许操作other的私有成员m_data
      int length = strlen(other.m_data);  
      m_data = new char[length+1];
      strcpy(m_data, other.m_data);
    }
    // 赋值函数
    String & String::operate =(const String &other)
    ...{   
        // (1) 检查自赋值
        if(this == &other)
            return *this;
        // (2) 释放原有的内存资源
        delete [] m_data;
        // （3）分配新的内存资源，并复制内容
        int length = strlen(other.m_data);  
        m_data = new char[length+1];
        strcpy(m_data, other.m_data);
        // （4）返回本对象的引用
        return *this;
}   
 类String拷贝构造函数与普通构造函数的区别是：在函数入口处无需与NULL进行比较，这是因为“引用”不可能是NULL，而“指针”可以为NULL。

 

（1）第一步，检查自赋值。你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自赋值语句的确不会。但是间接的自赋值仍有可能出现

 

（2）第二步，用delete释放原有的内存资源。如果现在不释放，以后就没机会了，将造成内存泄露。

（3）第三步，分配新的内存资源，并复制字符串。注意函数strlen返回的是有效字符串长度，不包含结束符‘/0’。函数strcpy则连‘/0’一起复制。

（4）第四步，返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。那么能否写成return other 呢？效果不是一样吗？

不可以！因为我们不知道参数other的生命期。有可能other是个临时对象，在赋值结束后它马上消失，那么return other返回的将是垃圾。

3.函数隐藏。

#include<iostream>
    using namespace std;
 
    class B ...{
    public:
        int f(int i) ...{ cout << "f(int): "; return i+1; }
        // ...
    };
 
    class D : public B ...{
    public:
      //  using B::f;   试试注释掉和不注释掉的差别。 
        double f(double d) ...{ cout << "f(double): "; return d+1.3; }
        // ...
    };
 
    int main()
    ...{
        D* pd = new D;
 
        cout << pd->f(2) << ' ';
        cout << pd->f(2.3) << ' ';
    }

 未完再续。。。