C++ 类函数经验二则

自己水平菜，找书看得到如下二则：

C++ 类函数处理经验二则

一、类里面的函数指针

类中的函数指针，所对应的不是函数，而是一个变量，c++标准一直没有对此发表具体的标准。

如下，他既然是变量当然就不可以赋值函数的地址：

#include <iostream>

#include <string>

using namespace std;

 

void fun() {

   cout << "asdf" <<endl;

}

 

class dd{

public:

   dd();

   int a_int;

   string a_str;

   void (*p)();

   void (*fun)() ;

   /*

    *这里不可以这么写，因为p、fun以及fun1都是被当作成员变量而不是函数！

   void (*fun1)() {

      cout << "fun1" << endl;

   }

   */

   ~dd() {}

};

 

dd::dd() {

   a_int = 10;

   a_str = "asdf";

   fun = ::fun;  //引入全局变量fun函数的地址

   p = fun; //相当与赋值

}

 

int main(int argc, char *argv[]) {

   dd a;

   a.p();

}

 

二、函数的名字隐藏

名字隐藏主要是发生在局部的名字隐藏了外部的名字，一般的变量很容易理解，但是类里面的函数重写和重载的出现就有点麻烦了，特别是基类和派生类的关系。

有一点遵循，就是一旦派生类出现了和基类同名的函数，不管是重载和重写，注意重写和重载不是一回事，到底是怎么一回事，google，基类的函数都将被隐藏，加不加virtual并不影响这种格局，还有重载要合法：

1、基类的所有函数都被重写，而且出现重载：

class fun1{

public:

   fun1();

   virtual void print(long );

   virtual void print(string );

   void g(long);

   void g(double);

private:

   string str;

};

 

class sub_fun1 : public fun1{

public:

   sub_fun1() : fun1() {

   }

   void print(string); //全部重写基类的print函数

   void print(long );

   void g(long);       //全部重写基类的g函数

   void g(double);

   void print(fun1);   //重载print

   void g(fun1);    //重载g

private:

 

};

这种情况，基类的同名函数都被屏蔽，重载的函数也照常工作。

2、仅仅全部重写基类某一类同名函数的时候，如：

class fun1{

public:

   fun1();

   virtual void print(long );

   virtual void print(string );

   void g(long);

   void g(double);

private:

   string str;

};

 

class sub_fun1 : public fun1{

public:

   sub_fun1() : fun1() {

   }

   void print(string);

   void print(long ); //g函数得到继承

private:

 

};

派生类的重写的函数将屏蔽基类的同名函数如print，但是没有重写的函数将继承，如g函数。

3、对一类函数的部分重写，不管出现或者不出现重载，没有被重写的函数将被屏蔽。

4、对基类的函数没有重写，但是在派生类中出现了同名函数的重载，那么基类的同名函数将被全部屏蔽。

5、如果既不重写也不重载，那么基类所有的函数都将被继承。

总结，调用一个被屏蔽的函数，得到的就是一个编译期错误！

最后看一个实例：

//Funtion.h

 

#include <iostream>

#include <string>

 

using namespace std;

class fun1{

public:

   fun1();

   explicit fun1(string );

   virtual void print(long );

   virtual void print(string );

   void g() {

      cout << "g()" << endl;

   }

private:

   string str;

};

 

class sub_fun1 : public fun1{

public:

   sub_fun1() : fun1() {

   }

   void print(string);

   //这里重写的string参数的print函数，屏蔽了float和long参数的print函数，

   //对g函数没有重写也没有重载

   //void print(float );

   //void print(long );

private:

 

};

 

///functon.cpp

#include "funtion.h"

 

fun1::fun1() {

   str = string("fun1");

}

 

fun1::fun1(std::string a_string) {

   str = string(a_string);

}

 

void fun1::print(string a_int) {

   cout << a_int <<endl;

}

 

void fun1::print(long a_fun1_long) {

   cout << a_fun1_long << endl;

}

 

/*

void sub_fun1::print(long a_long) {

   cout << a_long <<endl;

}

 

void sub_fun1::print(float a_float) {

   cout << a_float << endl;

}

*/

void sub_fun1::print(std::string a) {

   cout << a << endl;

}

 

 

///main.cpp

#include "funtion.h"

 

int main() {

   fun 1 a ;

   fun 1 c ("dddd");

   sub_fun1 b;

   //b.print(12.3);调用被屏蔽了的函数，得到的时候一个编译期错误

   //b.print(12);也是编译期错误

   b.print("sub_fun1");

   b.g();

}