C++——函数重载，引用(c++中重载函数是什么)

java8

帖子摘要：?主页我的代码爱吃辣知识讲解C 创作者我的代码爱吃辣 ??开发环境Visual Studio 2022 前言补充C语言语法的不足以及C是如何对C语言设计不合理的地方进行......

  M3 S( l% n6 P8 Y大家好，欢迎来到Java吧（www.java8.com），交流、学习Java技术、获取Java资源无任何套路，今天说一说：“C++——函数重载，引用”
) _) P" W$ M) n* _1 c. D" c




2 j7 v4 n. X) e" s  ?主页我的代码爱吃辣
6 A/ q, c6 E6 a7 W' }& q 知识讲解C++
3 Y" f) B) \8 h- b4 | 创作者我的代码爱吃辣/ [6 K$ G0 t1 j3 Y; e
??开发环境Visual Studio 2022
: d. Y+ q3 [: W6 e+ }! k 前言补充C语言语法的不足以及C++是如何对C语言设计不合理的地方进行优化的比如作用域方面、IO方面、函数方面、指针方面、宏方面等。( `, ]) X' P  ~; `' _

: B$ [4 m9 Y1 x; z/ B
目录

一.函数重载

(1)函数重载概念

1.参数类型不同

2.参数个数不同

3.参数类型顺序不同

(2)C++函数重载的原理

二.引用

1引用的概念

2引用特征

1.引用在定义时必须初始化

2.一个变量可以有多个引用

3.引用一旦引用一个实体再不能引用其他实体

3常引用

4 使用场景

1.做参数

2.作为返回值

5传值、传引用效率比较

6引用和指针的区别

一.函数重载
在自然语言中一个词可以有多重含义人们可以通过上下文来判断该词真实的含义即该词被重
载了。
比如以前有一个笑话国有两个体育项目大家根本不用看也不用担心。一个是乒乓球一个
是男足。前者是“谁也赢不了”后者是“谁也赢不了”

(1)函数重载概念
函数重载是函数的一种特殊情况C++允许在同一作用域中声明几个功能类似的同名函数这
% T6 K. t) H# e" S 些同名函数的形参列表(参数个数或类型或类型顺序)不同常用来处理实现功能类似数据类型
6 \" ^3 Q8 F( b: [9 h 不同的问题。

1.参数类型不同

int Add(int left, int right)
{
        cout  
 
# O6 U- `5 z1 j7 H6 c
[img]/f51b080ce5564d6a88f6348a162ac709.png[/img]
 
2 t" H! d- N- [/ W
2.参数个数不同 
5 t8 Q! B# u; R6 z* I+ S" a
[code]void f()
% s; H) n- p7 `1 B' u6 a7 r
{
0 J+ V3 P5 G4 o7 q
        cout  
3.参数类型顺序不同 
[code]void f(int a, char b)
{
, @2 \6 d- w9 e2 ^5 p% J/ M
        cout  
(2)C++函数重载的原理[/size] 
) J3 G, L) w8 j4 E* X% N
我们知道C语言不支持函数重载为什么C语言不支持函数重载呢当有两个函数名相同的函数时C语言就已经无法区分了是因为C语言仅仅就是通过函数名来区分每个函数。但是在C++里面C++通过对函数名配合参数进行修饰就可以通过函数名以及函数参数特点对每个函数进行区分。
 
8 Y( f* o0 W0 I4 y
[b]通过这里就理解了C语言没办法支持重载因为同名函数没办法区分。而C++是通过函数修
 饰规则来区分只要参数不同修饰出来的名字就不一样就支持了重载。[/b]
5 R' ]# E. C: e! Q; F
 
[b]如果两个函数函数名和参数都是一样的仅仅是返回值不同是不构成重载的因为调用时编译器没办法区分。[/b]
# O  n1 i9 e2 y/ ]3 Q& b
 
二.引用 
1引用的概念[/size] 
0 V, N5 r* v/ k1 w
[b]引用不是新定义一个变量而是给已存在变量取了一个别名编译器不会为引用变量开辟内存空
5 r/ c, X1 \$ s5 E: @8 ~& e5 j
 间它和它引用的变量共用同一块内存空间。[/b]
0 \8 p! x! _1 F8 w) g
 
9 D( i7 r" H+ J9 h
比如李逵在家称为"铁牛"江湖上人称"黑旋风"。
 
: C$ \5 h6 A( |* m
[b] 类型& 引用变量名(对象名) = 引用实体[/b]
0 E5 l! w' X8 Z( [9 `8 @
 
看一段代码
 
[code]#include[i]
6 Z0 U8 V1 ^# m( _+ h
using namespace std;
int main()
{
/ Q0 G, y$ c% h
        int a = 10;
        int& ra = a;
  ~8 O) b  Q* p0 R! t9 i2 F7 V
        std::cout  
! `5 d' N  q7 C
 
[img]/085dfbe83c9e4a998628464eef06214c.png[/img]
 
4 K' [, l2 ^* r
[b]引用和对象使用同一块空间:[/b]
' T  G) v; s9 U: u* e3 ?
 
[code]int main()
{
        int a = 10;
2 h1 U) K0 g1 V
        int& ra = a;// 
[img]/d1dded1f21764a8f81abab2a4231f512.png[/img]
 
# T+ Q! Y7 J1 f3 u+ V
 大家还记得这段代码吗
 
, D  A6 n; J  ?% b1 [# d) t. Y
[code]void ListPushBank(ListNode**phead,int x)
{
        ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
* F& L2 A6 N" h8 Z" {0 a; ~
        newhead->val = x;
        newhead->next = NULL;
: R  U! [% o4 |! Q4 |' w
        if (*phead == NULL)
        {
                *phead = newhead;
        }
        else
        {
                ListNode* Tail = *phead;
3 t$ y  i: {' Q( _$ C' H, a
                while (Tail->next)
4 K& b3 d/ @) @6 z" e& h% U: ^6 F) f
                {
! r4 W" a/ z+ f- e1 A/ y
                        Tail = Tail->next;
; C  p9 r( o' W9 `: @% r' k: u
                }
5 M. O# s# a# e8 n
                Tail->next = newhead;
4 y% Q8 d+ V! H( I
        }
}
int main()
$ k' }9 A5 p* e: \" L
{
        ListNode* head=NULL;
        ListPushBank(&head,100);
1 W, W; I% b* r( K0 l3 p0 u/ M
        ListPushBank(&head, 200); 
9 l  w# T# W/ X
        return 0;
6 f9 l5 Y2 i& b) x
}
复制代码

在PushBank时如果我们遇到第一个结点时就需要把第一个结点作为头结点此时需要更改函数外面的 head 指针就必须要 head 的地址在函数里面就得使用二级指针。

现在我们有了引用就可以很方便的解决这个问题

void ListPushBank(ListNode*& phead, int x)
{
% D* `$ S+ p9 K- D+ }' B
        ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
        newhead->val = x;
9 X6 |0 G$ v' ]3 S% x1 i/ }
        newhead->next = NULL;
: j4 M6 s4 _7 r8 G2 k  t+ [
        if (phead == NULL)
& v" \2 w2 l/ d) k
        {
; \% ]6 a1 h9 v1 f
                phead = newhead;
        }
" M& J! S; m5 |3 U$ c
        else
        {
                ListNode* Tail = phead;
7 W: i! K0 j1 L
                while (Tail->next)
                {
; y( ~# F/ |$ H1 r( T# {+ }
                        Tail = Tail->next;
                }
                Tail->next = newhead;
        }
4 I. B7 j8 ^7 G, ]1 ^* q
}
int main()
- m7 v( I- @8 H' v! z
{
        ListNode* head = NULL;
' l! e1 R. D: m. k9 w7 a
        ListPushBank(head, 100);
, ^6 g7 e( ]! c5 l8 Q# l$ a
        ListPushBank(head, 200);
        
+ a' w2 H/ j! O$ N$ I+ l1 b
        return 0;
}
复制代码

2引用特征
引用有一些很重要的特征需要我们注意

1.引用在定义时必须初始化

这里不难可能出语法直接时报错的。

2.一个变量可以有多个引用

nt main()
' I: {* L! n9 c# g
{
: \% J$ m# H, s
        int a = 10;
        int& ra = a;
        int& rb = a;
        int& rc = a;
        
! \, a( s; H- z& R% d1 {
        printf("ra=%d,rb=%d,rc=%d\n",ra,rb,rc);
; g- I8 R! v+ E9 J7 W+ {2 i
        return 0;
}
复制代码

. q4 g5 d* D( d& Z b% [) R+ G: @0 ~
一个变量可以有多个引用并且多个引用都共用一个地址空间。9 ~# }0 Q8 X7 Z* H9 {' g! }4 E
$ r9 _& U# C* F/ p6 [4 Z' F' j

3.引用一旦引用一个实体再不能引用其他实体

int main()
{
0 H1 R( H3 o1 D5 j4 t
        int a = 10; 
4 }) e# n( k& C. `: A2 J. h# D
        int b = 30;
        int& ra = a;
        ra = b;//仅仅只是把b的值赋值给了ra
        std::cout  
[img]/2701e3ac5b934260b5bcb2086c6418bd.png[/img]
8 ?, U+ c: W% z0 p
 
[b] 
$ w, [5 `# t1 }( g: s& p) _/ e
 [b] a与ra 仍然公用一块空间ra = b并没有改变ra的引用实体实际上也改变不了ra的引用实体。[/b]
# c6 P; b4 {+ \# X; U) m
 
0 Z, w* o5 g( D6 E9 u4 k3 e
[/b] 
 3常引用[/size] 
: J6 f' d7 j) j" ~
[b]变量权限可缩小或平移但不可放大[/b]
 
( W/ b' _2 c8 c) @0 x: {# D% c* j6 w
[b] 场景一[/b]
4 \9 b1 b' F  B( b9 ~
 
[img]/04bbea8e44e74732b3376d0f79ff596b.png[/img]
: x. G  V" L$ v$ D# U
 
. o4 G, f3 s% s3 X6 Z
[b] 
 [b] 因为常量只具有可读属性如果引用成功的话就可以通过引用来实现对变量的修改变量权限就是放大了这样也是说不通的。[/b]
 
! N8 G: U. W) r$ N& I8 C
[/b] 
 但是也不是没有办法使得引用的实体是常量。
 
" {3 u3 `$ Q$ u3 W  U( ~
[img]/c776fa352b284427a1dd3f60d49b1775.png[/img]
 
# L4 _8 p2 ]( n& P! U5 B9 P/ \
[b] 
 [b] 变量是只可读的变量的引用对象也只能是可读的这也就是变量权限平移.[/b]
 
[/b] 
 上述的结论不仅针对引用对指针也是有着同样的效果
) z# }: ^; V( K  |/ S; V4 v
 
4 |- l8 O& W& g3 D; C) Y+ B
[img]/14583405934f4946b983152b595a9570.png[/img]
 
7 `0 d1 W% u( i: z9 Q- q- X
[b] 场景二[/b]
 
[img]/8ad30a1367dd4a9785bc0596212141ec.png[/img]
 
[b] 
 [ol][*]这里的报错大家是不是认为是类型的原因导致的但是往后看加上一个const就没有报错了而且仍然是int类型的引用。[*][b]首先来了解类型转的原理类型转换是有一个中间变量的而引用的对象的就是那个临时变量因为临时变量具有常属性所以加上一个 const 就可以消除报错。[/b][/ol]
- f8 j  S' w+ s5 R# J# |: R
[/b] 
4 使用场景[/size] 
1.做参数 
我们之前使用指针实现函数来交换两个变量的值
1 X: J  f' @& d6 ]6 y$ q
 
[code]void Swap(int* pleft, int* pright)
9 _2 U5 I6 t) Q7 I3 E# q) W
{
        int tmp = *pleft;
        *pleft = *pright;
8 c3 u" H  Y1 ?( b6 z$ d. X
        *pright = tmp;
}
复制代码

原理我就不多解释了想必大家都已经熟记于心了今天我们用引用也可以实现

[code]void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int a = 10; int b = 20;
std::cout

2.作为返回值
[code]int& add(int a, int b)
{
int sum = a + b;
return sum;
}
int main()
{
int& ret = add(1, 2);
std::cout

问题来了我们只对ret进行了一次赋值但是两次输出却是两个值。这又是为什么呢

# I7 @) Z& B3 [0 f& A
怎样可以返回引用呢其实只要出了函数作用域函数的返回值还在就可以返回引用。
: m: A% M. J0 m6 c7 Z% ~ 3 s4 n# {4 H4 ?* `
例如static 修饰的变量存储在静态区不会因为函数栈帧的销毁而销毁。
: g( o4 X# W( J9 [- c, W6 J
$ _) U/ ?2 z# j# O4 E; t

[code]
int& add(int a, int b)
{
static int sum = a + b;
return sum;
}
int main()
{
int& ret = add(1, 2);
std::cout

$ i) S/ |3 \3 N 注意如果函数返回时出了函数作用域如果返回对象还在(还没还给系统)则可以使用引用返回如果已经还给系统了则必须使用传值返回。
8 a/ {4 \. Y0 |7 Q) h+ C5 G0 X 3 S$ Q. _5 g+ M: b) l b

5传值、传引用效率比较
以值作为参数或者返回值类型在传参和返回期间函数不会直接传递实参或者将变量本身直
接返回而是传递实参或者返回变量的一份临时的拷贝因此用值作为参数或者返回值类型效
率是非常低下的尤其是当参数或者返回值类型非常大时效率就更低。

[code]struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i

[code]struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i

通过上述代码的比较发现传值和传引用在作为传参以及返回值类型上效率相差很大。

6引用和指针的区别
# j$ ^8 E0 @+ u+ L% o( K

在语法概念上引用就是一个别名没有独立空间和其引用实体共用同一块空间。

在底层实现上实际是有空间的因为引用是按照指针方式来实现的。
+ \; d" X. v9 q2 n- x. f

引用和指针的不同点:

% @" o O7 i! v% w. c6 @! z3 ] [ol]

引用概念上定义一个变量的别名指针存储一个变量地址。

引用在定义时必须初始化指针没有要求。

引用在初始化时引用一个实体后就不能再引用其他实体而指针可以在任何时候指向任何一个同类型实体。

没有NULL引用但有NULL指针。

在sizeof中含义不同引用结果为引用类型的大小但指针始终是地址空间所占字节个数(32 位平台下占4个字节)。

引用自加即引用的实体增加1指针自加即指针向后偏移一个类型的大小。

有多级指针但是没有多级引用。

访问实体方式不同指针需要显式解引用引用编译器自己处理。

引用比指针使用起来相对更安全。[/ol]8 ~6 W2 T% x% B) i$ h) z2 U2 T) J8 H

本文来源csdn，由Java吧转载发布，观点不代表Java吧的立场，转载请标明来源出处：https://www.java8.com

C++——函数重载，引用(c++中重载函数是什么)

java8 LV9