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<chmetcnv w:st="on" tcsc="0" numbertype="1" negative="False" hasspace="True" sourcevalue="1" unitname="a">1 a</chmetcnv>;

fun<chmetcnv w:st="on" tcsc="0" numbertype="1" negative="False" hasspace="True" sourcevalue="1" unitname="C">1 c</chmetcnv>("dddd");

sub_fun1 b;

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

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

b.print("sub_fun1");

b.g();

}