高质量C++/C编程学习笔记(五)----- 基础函数的高级特性

本文深入探讨了C++中的重载、extern C、重写与覆盖的区别、内联函数的应用以及成员函数的组织方式等内容,帮助读者理解并掌握这些重要的编程技巧。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、重载:

只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函数产生不同的内部标识符。

如void Test(int …);void Test(char…);void Test(float…); 编译器有可能会为这三个函数产生三个像_test_int、_test_char、_test_float 之类的内部标识符,当做不同的编译器可能产生不同风格的内部标识符,上面这种风格是我自己推测的。这也许就是重载的原理吧。

有一点需要注意的是,并不是函数名相同参数不同就能构成重载,如全局函数和类的成员函数同名就不算:

 

void Print(…);  //  全局函数 
 class A 
 {… 
  void Print(…); //  成员函数 
  }

这时可以用::print(……) 来标识全局变量 

还有,写重载时,不要写成如下形式:

 

void output( int x); 
void output( int x, float y=0.0); 

 这样的话,调用ouput(1); 就会报错。

 

2、extern “C” 

举例:void foo(int x, int y); 

该函数被 C 编译器编译后在库中的名字为_foo,而 C++编译器则会产生像_foo_int_int之类的名字用来支持函数重载和类型安全连接。由于编译后的名字不同,C++程序不能直接调用 C 函数。C++提供了一个 C 连接交换指定符号 extern“C”来解决这个问题。

例如: 

extern “C” 

   void foo(int x, int y); 

   … //  其它函数 

或者写成 

extern “C” 

   #include “myheader.h” 

   … //  其它 C 头文件 

 

这就告诉 C++编译译器,函数 foo 是个 C 连接,应该到库中找名字_foo 而不是找_foo_int_int。C++编译器开发商已经对 C 标准库的头文件作了 extern“C”处理,所以我们可以用#include  直接引用这些头文件。

 

3、重写与覆盖中的与“隐藏”相关的规则

 

  3.1 如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无 virtual 关键字,基类的函数将被隐藏(注意别与重载混淆)

 

  3.2 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有 virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)

给个网上的例子

 

#include <iostream.h> 
 class Base 
{ 
public: 
  virtual void f(float x){ cout << "Base::f(float) " << x << endl; } 
  void g(float x){ cout << "Base::g(float) " << x << endl; } 
  void h(float x){ cout << "Base::h(float) " << x << endl; } 
}; 
 class Derived : public Base 
{ 
public: 
  virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } 
  void g(int x){ cout << "Derived::g(int) " << x << endl; } 
  void h(float x){ cout << "Derived::h(float) " << x << endl; } 
}; 
void main(void) 
{ 
Derived  d; 
Base *pb = &d; 
Derived *pd = &d; 
// Good : behavior depends solely on type of the object 
pb->f(3.14f); // Derived::f(float) 3.14  
pd->f(3.14f); // Derived::f(float) 3.14 
 
// Bad : behavior depends on type of the pointer 
pb->g(3.14f); // Base::g(float) 3.14  
pd->g(3.14f); // Derived::g(int) 3        (surprise!) 
 
// Bad : behavior depends on type of the pointer 
pb->h(3.14f); // Base::h(float) 3.14      (surprise!) 
pd->h(3.14f); // Derived::h(float) 3.14  
} 

 

 如果语句 pd->f(10)一定要调用函数 Base::f(int),那么将类 Derived 修改为如下即可。

 

class Derived : public Base 
{ 
  public: 
  void f(char *str); 
  void f(int x) { Base::f(x); } 
}; 

 

4、用内联取代宏代码

 

预处理器用复制宏代码的方式代替函数调用,省去了参数压栈、生成汇编语言的CALL 调用、返回参数、执行 return 等过程,从而提高了速度。使用宏代码最大的缺点是容易出错,如:

 

 #define MAX(a, b)       (a) > (b) ? (a) : (b) 
//下面的语句  就会得不到自己想要的结果
result = MAX(i, j) + 2 ; //相当于 result = (i) > (j) ? (i) : (j) + 2 ; 

 宏还有一个缺点,就是无法操作类的私有数据成员。

这时可以考虑用内联函数 

使用如下: 

 void Foo(int x, int y);   // 先声明

 inline void Foo(int x, int y) // inline 与函数定义体放在一起 , 不用放在声明上,这样比较规范一点

 { 

  … 

 }

其实 内联是以代码膨胀(复制)为代价,仅仅省去了函数调用的开销,从而提高函数的执行效率。如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收获会很少。另一方面,每一处内联函数的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间。以下情况不宜使用内联: 

(1)如果函数体内的代码比较长,使用内联将导致内存消耗代价较高。 

(2)如果函数体内出现循环,那么执行函数体内代码的时间要比函数调用的开销大。

 

5、将成员函数的定义体放在类声明之外

放在类声明之中虽然能带来书写上的方便,但不是一种良好的编程风格,应该改成如下形式: 

 

 //  头文件 
class A 
 { 
public: 
  void Foo(int x, int y);  
 } 
 //  定义文件 
 inline void A::Foo(int x, int y) 
{ 
… 
}
 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值