第一课:C过渡到C++--之二

时间:2021-11-23 20:09:50

函数重载

C++的函数重载机制为我们程序员提供了很大的便利,但同时也会带来一些问题,这时我们会发现,当我们调用重载函数时,会出现编译不通过的现象,还有给别人提够函数接口也会出现一些问题。

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char c)
{
printf("%c\n", c);
}

void MyPrintf(int i)
{
printf("%d\n", i);
}

int main()
{
char c = 'A';
MyPrintf(c);
short s = 100;
MyPrintf(s);

return 0;
}

居然可以编译通过,并将正确答案显示出来,是不是太神奇了???
然而细心的朋友会发现,我们并没有重载short的函数,而为什么能够正确编译和输出呢?这是因为进行了提升匹配,short类型自动提升到了int类型,所以程序能够成功编译和运行。
但是重载有些时候还是会出问题的比如下面的例子:

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char c)
{
printf("%c\n", c);
}

void MyPrintf(int i)
{
printf("%d\n", i);
}

void MyPrintf(float f)
{
printf("%f\n", f);
}

int main()
{
char c = 'A';
MyPrintf(c);
short s = 100;
MyPrintf(s);
unsigned int ui = 200;
MyPrintf(ui);

return 0;
}

此时的MyPrintf(ui);就会编译不通过,会提示下面的信息:
第一课:C过渡到C++--之二
从这个错误提示上可以看出,我们调用unsigned int类型的变量时,它可以有多重调用方式,这样就会使得编译器很困惑,所以就会导致编译错误。那么怎样才能修改这样的代码,使它能够通过编译呢?很简单的一种就是再增加一个unsigned int类型的重载函数,代码如下:

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char c)
{
printf("%c\n", c);
}

void MyPrintf(int i)
{
printf("%d\n", i);
}

void MyPrintf(float f)
{
printf("%f\n", f);
}

void MyPrintf(unsigned int ui)
{
printf("%d\n", ui);
}

int main()
{
char c = 'A';
MyPrintf(c);
short s = 100;
MyPrintf(s);

unsigned int ui = 200;
MyPrintf(ui);

return 0;
}

这样就能够很顺利的通过编译,但是我们应该如何去写重载函数呢?究竟写多少个重载函数才好呢?这个应该看具体项目需求,需要写几个就写几个,并不是说重载函数写得越多越好,因为多了也没用。

重载函数的总结

重载函数的匹配规则:
1.精准匹配,比如 int -> int
2.提升匹配,比如 char -> int -> double
3.类型转换匹配,int -> unsigned int
所以当重载函数的匹配规则发生冲突或者有多个匹配函数时,就会出现二义性。定义太多或太少的重载函数时容易出现问题

特别需要注意的是,千万不要使用指针类型进行重载函数

请看这样指针重载的例子

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char *str)
{
printf("%s\n", str);
}

void MyPrintf(int *pI)
{
printf("%d\n", *pI);
}

int main()
{
char *str = "AAA BBB CCC";
MyPrintf(str);
int i = 100;
int *pI = &i;
MyPrintf(pI);

return 0;
}

此时的重载和调用都没有问题,可以编译通过和正确运行,但是如果我有一个万能指针void*的变量时,程序又会出现什么情况呢?
还是先看代码吧

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char *str)
{
printf("%s\n", str);
}

void MyPrintf(int *pI)
{
printf("%d\n", *pI);
}

int main()
{
char *str = "AAA BBB CCC";
MyPrintf(str);
int i = 100;
int *pI = &i;
MyPrintf(pI);
void *p = nullptr;
MyPrintf(p);

return 0;
}

上面的代码在编译时,就会出现问题。编译的错误提示信息如下:
第一课:C过渡到C++--之二
为什么会出现这样的错误呢?原因很简单,因为void*的变量是万能指针嘛,它可以转换成任意的指针的类型,所以此时就会出现二义性,编译器也不知道该调用哪个函数了。

默认参数

C++的特性中,有一个默认参数的特性,就是我们可以给函数参数默认的赋值,代码如下:

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char c, bool bLine = false)
{
printf("%c", c);
if (bLine)
printf("\n");
}

int main()
{
char c = 'A';
MyPrintf(c, true);
c = 'B';
MyPrintf(c);
c = 'C';
MyPrintf(c, false);

return 0;
}

首先,肯定一点是上面的代码没有错误,它的输出结果是:
第一课:C过渡到C++--之二
从输出结果上可以看出,当我们给它传递一个true参数时,就表示有换行,而不传递参数,那么它就会使用默认参数false,这和我们显示的传递false的效果是一样的。

需要注意的时,默认参数还是有条件的,比如默认参数必须要从右到左赋值默认参数,不允许有默认值的参数右边是没有默认值的参数。

比如:

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
void MyPrintf(char c, bool bLine = false, int i)
{
printf("%c", c);
if (bLine)
printf("\n");
}

int main()
{
/*char c = 'A';
MyPrintf(c, true);
c = 'B';
MyPrintf(c);
c = 'C';
MyPrintf(c, false);
*/

return 0;
}

此时,我们就是不调用这个函数,它也不会编译通过,其实这也没有什么好解释的,记住就可以了。

内联函数

内联函数的写法很简单,直接在函数名前直接加上inline关键字就可以了,代码如下:

#include "stdafx.h"
#include <iostream>

// 以输出不同类型的参数为例的重载函数
inline void MyPrintf(char c, bool bLine = false)
{
printf("%c", c);
if (bLine)
printf("\n");
}

int main()
{
char c = 'A';
MyPrintf(c, true);
c = 'B';
MyPrintf(c);
c = 'C';
MyPrintf(c, false);

return 0;
}

从代码上可以看出,内联函数的使用和普通函数一样,没有任何的差别。

内联函数的好处

内联函数不会新建栈,而是直接将代码展开,这样就会大大的提高了函数的执行效率,因为减少了创建栈,销毁栈的过程。需要注意的是,内联函数只是针对栈空间来说的,比如说在堆空间申请的内存和释放跟内联是没有关系的。只有在栈空间上执行的函数才有可能被内联。

内联函数既然有好处,肯定也有它的缺点

内联函数的缺点是,它会造成代码的膨胀,使生成的可执行程序变得庞大。

内联函数的作用

inline关键字只是告诉编译器这个函数要内联,但是具体能不能成功的内联,是由编译器来决定。具体的规则也不太好说清,据听说是内联的规则是经常变化的,所以也没有一个固定的准则。但是大概有一些规则,只能说是一般性的规则。
通常情况下判定标准:
1.代码量很庞大
2.不加inline,他不会变成内联函数,但是加上的话,也不一定内联

内联和宏定义的区别

内联函数和宏定义都是直接展开,那它们之间有什么区别呢?
宏定义是赤裸裸的替换,不带半点儿的修饰,没有一点儿类型检测;
内联函数,它毕竟还是函数,所以它有类型检测;

类型转换

C++的类型转换与C语言的类型转换不同,C语言的类型转换都是强制转换的。而C++中有四中类型转换,只有一种类型转换等同于C语言的强制类型转换,其它的三种转换都不是强制转换。他们分别是:
1.static_cast它不是强制转换,只是简单的转换,是C++的转换风格
2.const_cast表示去常量操作,但是它还是不能真正的去掉参数的常量,我们可以认为只是蒙骗编译器通过编译,没有其他的作用了。
3.dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换
4.reinterpret_cast此标识符的意思即为数据的二进制形式重新解释,但是不改变其值
我们先了解这几种转换关系,以后再做深入的解释和说明。