C++进阶2：重载原理分析

最新推荐文章于 2023-08-20 23:54:15 发布
最新推荐文章于 2023-08-20 23:54:15 发布
阅读量480 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42278523/article/details/107414140
版权

1. 基本原理知识

函数重载：在相同作用域中的多个函数，具有相同的名字而形参表不同。

不能仅仅基于不同的返回类型而实现函数重载。返回值是不影响函数签名的。

C++函数重载底层实现原理是C++利用name mangling(倾轧)技术，来改名函数名，区分参数不同的同名函数。

编译器通过函数名和其参数类型识别重载函数。为了保证类型安全的连接（type-safe linkage），编译器用参数个数和参数类型对每一个函数标识符进行专门编码，这个过程有时称为“名字改编”（name mangling）或“名字修饰”（name decoration）。类型安全的连接使得程序能够调用合适的重载函数并保证了参数传递的一致性。编译器能够检测到并报告连接错误。

objdump -t 查看符号表

_Z开头的文件；（重载文件）

2. gcc编译

不能压榨，所以不能进行重载；

  • test.c
   int func(int a){};
  • 编译
gcc -c test.c -o test.o
  • 查看符号
 objdump -t test.o
函数名名字改编
int func(int a);func

3. g++编译

  • test.cpp
int func(int a){};
int func(int a,int b){};
  • 编译
 g++ -c test.cpp -o test.o
  • 查看符号
  objdump -t test.o
函数名名字改编
int func(int a);_Z4funci
int func(int a,int b);_Z4funcii

_Z是规定前缀，4是函数名的字符个数，i是参数列表类型i的首字母

注意：不同系统和编译器的命名倾轧方式是有所不同的。

4. 命名反倾轧

名字改编转化成函数名

使用 c++filt 命令可以很容易把名字改编转换成函数名。
例如：

   c++filt _Z4funci

5. 实例

（1）编写代码

 #include <stdio.h>
void Func(int,int){}
void Func(int){}
void Func(){}
class Simple{
    int n;
public:
    Simple(int n):n(n){}
    Simple(const Simple&){}
    Simple& operator=(const Simple&){
        return *this;
    }
    ~Simple(){}
    void Func(){}
};

int main(){
    Simple s(10);
    Simple s1 = s;
    s1 = s;
//    printf("Func=%p\n",&Func);
    printf("main=%p\n",&main);
}

（2）编写代码

  • 编译
gcc -c test.c -o test.o
  • 查看符号
 objdump -t test.o
  • 反编译
c++filt _Z4funci

6. 禁用命名倾轧

C++命名倾轧的函数是无法被C语言调用的。C++的函数必须是没有倾轧的才能调用。
使用声明extern "C"的函数会禁止命名倾轧，这样C++的函数就可以被C语言调用。
编译出来的函数名仅仅保留名字，与gcc编译的结果一样；

（1）这样的函数不支持重载；

extern "C" int func(int a){
    return a*10;
}
#if(0)
int func(){
    return 0;
}
#endif
  • 完整案例
#include <iostream>
using namespace std;

extern "C" int func(int a){
    return a*10;
}


/*使用声明`extern "C"`的函数会禁止命名倾轧，这样C++的函数就可以被C语言调用。  
编译出来的函数名仅仅保留名字，与gcc编译的结果一样；
（1）这样的函数不支持重载；*/


#if(0)
int func(){
    return 0;
}
#endif



int main()
{
    int n = func(20);
    return 0;
}

6. 禁用命名倾轧

C++命名倾轧的函数是无法被C语言调用的。C++的函数必须是没有倾轧的才能调用。
使用声明extern "C"的函数会禁止命名倾轧，这样C++的函数就可以被C语言调用。
编译出来的函数名仅仅保留名字，与gcc编译的结果一样；
（1）这样的函数不支持重载；

extern "C" int func(int a){
    return a*10;
}
#if(0)
int func(){
    return 0;
}
#endif
  • 完整案例
#include <iostream>
using namespace std;

extern "C" int func(int a){
    return a*10;
}


/*使用声明`extern "C"`的函数会禁止命名倾轧，这样C++的函数就可以被C语言调用。  
编译出来的函数名仅仅保留名字，与gcc编译的结果一样；
（1）这样的函数不支持重载；*/


#if(0)
int func(){
    return 0;
}
#endif



int main()
{
    int n = func(20);
    return 0;
}

7. c/c++的交叉编译

7. 1 c++环境编译c文件

情况一：直接编译c文件
g++ xxx.c //直接编译c文件
情况二：c++里面使用c语言的语法
（1）添加需要的头文件；
（2）添加需要的函数，功能相同的话，选择c++里面的函数，避免矛盾；

7. 2 c环境编译c++文件

步骤一：头文件（array.h）需要注意：
（1）头文件里面包含cpp文件里面的函数声明，
（2）但是不能包含extern “C”，不识别；

int sum(int* arr, int n);
void reverse(int* arr, int n);
int max_element(int* arr,int n);

步骤二：（array.cpp）需要注意：
（1）使用extern “C”实现函数的实现；

//（1）使用extern “C”实现函数的实现；
 extern "C" int sum(int* arr, int n){
    return accumulate(arr,arr+n,0);
}

（2）不能使用流运算符和其头文件；

//（2）不能使用流运算符和其头文件；
//#include <iostream>

步骤三：测试函数（main.c）需要注意：
只能在main.c里面出现main（）函数，多个main（）函数会报错；

步骤四：编译（编译二进制文件），但是code::blocks不用这样，直接编译；
g++ -c array.cpp
gcc sum_test.c sum.o

  • array.h
/*
步骤一：头文件（array.h）需要注意：
（1）头文件里面包含cpp文件里面的函数声明，
（2）但是不能包含extern “C”，不识别；

*/
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED



int sum(int* arr, int n);
void reverse(int* arr, int n);
int max_element(int* arr,int n);


#endif // ARRAY_H_INCLUDED

(2)array.cpp

//#include <iostream>
//流运算符不能使用在array.cpp文件中；
//（2）不能使用流运算符和其头文件；
//#include <iostream>
#include <algorithm>
#include <numeric>
using namespace std;


//（1）使用extern “C”实现函数的实现；
 extern "C" int sum(int* arr, int n){
    return accumulate(arr,arr+n,0);
}

 extern "C" void reverse(int* arr, int n){
    reverse(arr,arr+n);

}

 extern "C" int max_element(int* arr, int n){
    return *max_element(arr,arr+n);
}


#if(0)
int main(){
    int arr[] = {1,3,5,2,7};
    cout << sum(arr,5) << endl;
    for_each(arr,arr+5,[](int n){
             cout << n << endl;});


}
#endif

(3)main.c

#include <stdio.h>
#include <stdlib.h>
#include "array.h"

//测试函数（main.c）需要注意：只能在main.c里面出现main（）函数，多个main（）函数会报错；

void Print(int* arr, int n){
    for(int i = 0;i < n;++i){
        printf("%d\t", arr[i]);
    }
    printf("\n");
}


int main()
{
    int arr[] = {1,4,2,6,9,3};
    printf("%d\n", sum(arr,6));
    printf("%d\n", max_element(arr,6));
    Print(arr,6);
    reverse(arr,6);
    Print(arr,6);
    return 0;
}

7. 3 c++和c之间都能使用头文件的方式

（1）将头文件修改为c_plus_plus和非c++类型；

#ifdef __cplusplus
    extern "C"{
 #endif // __cplusplus
int sum(int* arr, int n);
void reverse(int* arr, int n);
int max_element(int* arr,int n);

#ifdef __cplusplus
}
#endif

（2）声明中出现extern “C”，则实现中不用出现
（3）注意：#include
流运算符不能使用在array.cpp文件中；

  • 完整代码
    main.c ,main.cpp 二选一进行测试
  • array.h
#ifndef ARRAY_H_INCLUDED
#define ARRAY_H_INCLUDED

//（1）将头文件修改为c_plus_plus和非c++类型；
#ifdef __cplusplus
    extern "C"{
 #endif // __cplusplus
int sum(int* arr, int n);
void reverse(int* arr, int n);
int max_element(int* arr,int n);

#ifdef __cplusplus
}
#endif

#endif // ARRAY_H_INCLUDED
  • array.cpp
#include <iostream>
//流运算符不能使用在array.cpp文件中；
//#include <iostream>
#include <algorithm>
#include <numeric>
#include "array.h"
using namespace std;




 int sum(int* arr, int n){
    return accumulate(arr,arr+n,0);
}

 void reverse(int* arr, int n){
    reverse(arr,arr+n);

}

 int max_element(int* arr, int n){
    return *max_element(arr,arr+n);
}


#if(0)
int main(){
    int arr[] = {1,3,5,2,7};
    cout << sum(arr,5) << endl;
    for_each(arr,arr+5,[](int n){
             cout << n << endl;});


}
#endif
  • main.c
#include <stdio.h>
#include <stdlib.h>
#include "array.h"


//测试函数（main.c）需要注意：只能在main.c里面出现main（）函数，多个main（）函数会报错；

void Print(int* arr, int n){
    for(int i = 0;i < n;++i){
        printf("%d\t", arr[i]);
    }
    printf("\n");
}


int main()
{
    int arr[] = {1,4,2,6,9,3};
    printf("%d\n", sum(arr,6));
    printf("%d\n", max_element(arr,6));
    Print(arr,6);
    reverse(arr,6);
    Print(arr,6);
    return 0;
}
  • main.cpp
#include <iostream>
#include <algorithm>
#include <numeric>
#include "array.h"
using namespace std;


int main(){
    int arr[] = {1,3,5,2,7};
    cout << sum(arr,5) << endl;
    for_each(arr,arr+5,[](int n){
             cout << n << endl;});


}

7. 4 c可以使用c++定义的独特的方便的函数（接口）

在这里插入图片描述

（原理)（1）即编译的时候g++生成_Z开头的文件；
gcc生成和extern “C”生成Func文件；
（2）调用的时候，c调用Func；
c++调用_Z开头的文件；

  • 完整案例
    （1）array.h
#ifndef __VECTOR_H
#define __VECTOR_H

namespace miniSTL{
template<typename T>
class vector{
public:
    typedef T value_type;
    typedef T* pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef int size_type;

    typedef pointer iterator;
private:
    /*
    pointer   _data;     // 地址
    size_type _size;     // 元素个数
    size_type _capacity; // 容量大小
    */
    // 
    pointer _start; // _start == _data
    pointer _finish; // _size == _finish - _start; 
    pointer _endOfStorage; // _capacity == _endOfStorage - _start
public:
    vector():_start(NULL),_finish(NULL),_endOfStorage(NULL){}
    void push_back(const_reference val){
        if(NULL == _start){
            _start = new value_type[1];
            _finish = _endOfStorage =  _start+1;
            _start[0] = val;
            return;
        }
        int last = size();
        if( _finish==_endOfStorage){
            int new_capacity = capacity()*2;
            pointer tmp = new value_type[new_capacity];
            for(int i=0;i<last;++i){
                tmp[i] = _start[i];
            }
            delete [] _start;
            _start = tmp;
            _endOfStorage = _start+new_capacity;
        }
        _start[last] = val;
        _finish = _start+last+1;
    }
    void insert(iterator it,value_type val){
        // 此处省略申请空间的处理
        iterator last = end();
        while(last!=it){
            *last = *(last-1);
            last = last-1;
        }
        *it = val;
        ++_finish;
    }
    size_type size()const{return _finish-_start;}
    size_type capacity()const{return _endOfStorage-_start;}
    reference operator[](int index){ return _start[index];}
    reference at(int index){ return _start[index];}
    const_reference operator[](int index)const{ return _start[index];}
    // 迭代器
    iterator begin(){return _start;}
    iterator end(){return _finish;}
};
}

#endif // __VECTOR_H
  • array.cpp
#include <algorithm>
#include <numeric>
//#include "vector.h"
#include <vector>
#include "array.h"
using namespace std;
//using namespace miniSTL;

int sum(int* arr,int n){
    return accumulate(arr,arr+n,0);
}

void reverse(int* arr,int n){
    reverse(arr,arr+n);
}

int max_element(int* arr,int n){
    return max_element(arr,arr+n) - arr;
}
void* seq_create(){
    return new vector<int>();
}
void seq_destroy(void* seq){
    delete reinterpret_cast<vector<int>*>(seq);
}
void seq_append(void* seq,int val){
    reinterpret_cast<vector<int>*>(seq)->push_back(val);
}
void seq_prepend(void* seq,int val){
    vector<int>* p = reinterpret_cast<vector<int>*>(seq);
    p->insert(p->begin(),val);
}
int seq_size(void* seq){
    return reinterpret_cast<vector<int>*>(seq)->size();
}
int seq_get(void* seq,int index){
    return reinterpret_cast<vector<int>*>(seq)->at(index);
}
  • main.c
#include "array.h"
#include <stdio.h> 

void Print(int* arr,int n){
   for(int i=0;i<n;++i){
        printf("%d ",arr[i]);
   }
   printf("\n");
}
int main(){
    int arr[] = {1,4,2,6,9,3};
    printf("%d\n",sum(arr,6));
    printf("%d\n",max_element(arr,6));
    Print(arr,6);
    reverse(arr,6);
    Print(arr,6);

    void* seq = seq_create();
    seq_append(seq,1);
    seq_append(seq,2);
    seq_append(seq,3);

    for(int i=0;i<seq_size(seq);++i){
        printf("%d ",seq_get(seq,i));
    }
    printf("\n");

    seq_prepend(seq,0);
    seq_prepend(seq,-1);
    seq_prepend(seq,-2);

    for(int i=0;i<seq_size(seq);++i){
        printf("%d ",seq_get(seq,i));
    }
    printf("\n");



    seq_destroy(seq);

}

8. 空类

8.1. 空类的大小是多少？

1个字节

8.2. 编译器会给空类自动生成几个成员函数？

  1. 默认(缺省的)构造函数
  2. 析构函数
  3. 拷贝构造函数
  4. 赋值运算符重载函数
  5. 两个取址运算符重载函数
 class Empty {
      public:
        Empty(){}                            //缺省构造函数
        Empty(const Empty &rhs){}            //拷贝构造函数
        ~Empty(){}                           //析构函数 
        Empty& operator=(const Empty &rhs){} //赋值运算符重载函数
        Empty* operator&(){}                 //取址运算符重载函数
        const Empty* operator&() const{}     //取址运算符重载函数(const版本)
    };

调用时机

  Empty *e = new Empty();    //缺省构造函数
    delete e;                  //析构函数
    Empty e1;                  //缺省构造函数                               
    Empty e2(e1);              //拷贝构造函数
    Empty e3 = e1;             //拷贝构造函数
    e2 = e1;                   //赋值运算符
    Empty *pe1 = &e1;          //取址运算符重载函数(非const)
    const Empty *pe2 = &e2;    //取址运算符重载函数(const)

9.推荐阅读

阿华田咯
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
清华大学C++进阶讲义：第7章类的继承.pdf
01-22
第7章类的继承
初识C++ 函数重载以及背后的原理
玄鸟轩墨的博客
05-07 568
写在前面 先说说我的状态吧，五一假期五天假，这些天都在玩，很少学习，我不是后悔，也没必要，本来假期就是为了让自己放松.我唯一要反思看到别人在学,我心里也想学但是却做不到,这是我的缺点,后面我会克服的.尽量快点和大家分享知识.今天和大家分享的是C++关于函数重载的关系,我们不仅仅需要学会重载的使用,更要了解C++为什么支持函数重载. 函数重载 我们可能对函数很是熟悉,但是重载又是什么意思呢?我们先来用一个具体的场景来分享. 一天，张三的老板要你写一个两位数相加的函数,张三心想这不很简单吗?手指一动,结果就出来
C++——函数重载的原理，为何重载，如何重载
chfens的博客
08-04 786
C++函数重载的简介，通过Linux反汇编查看重载的原理。
c++函数重载原理
yue152152的博客
05-06 944
底层讲解C++函数重载原理，extern "C"的使用方法即原理
c++函数重载机制实现原理
05-30 9723
一、c++函数重载的定义：在同一作用域类，一组函数的函数名相同，参数列表不同（参数个数不同/参数类型不同），返回值可同可不同二、函数重载的作用：重载函数通常用来在同一个作用域内命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。三、函数重载是一种静态多态：（1）多态：用同一个东西表示不同的形态； （2）多态分为： 静态多态（编译时的多态） 动态
【C++入门篇—01函数重载的原理】
Kakakawhi的博客
05-12 330
C语言为什么不支持函数重载？C++支持函数重载的原理。
清华大学C++进阶讲义：第9章 模板与群体数据.pdf
01-23
清华大学讲义
清华大学C++进阶讲义：第10章 泛型程序设计与C++标准模板库.pdf
02-16
讲义
C++进阶课程讲义_v1.0.pdf
09-05
C++进阶课程讲义_v1.0
编译原理实践：C++实现语义分析器.rar
06-23
本资源使用C++实现了语义分析器，内容包括C++源代码与exe...该资源的文字版信息请访问博客《编译原理实践：C++实现语义分析器（学习笔记）》（https://blog.csdn.net/weixin_40589192/article/details/106934221）。
重载和重写的底层原理——虚拟机字节码执行引擎
eck_燃的博客
11-13 706
重载和重写的底层原理。我们分析了虚拟机在执行代码时，如何找到正确的方法，如何执行方法内的字节码，以及执行代码时涉及的内存结构。
函数重载
xiaoyali的专栏
08-09 8064
C++的函数至少在参数类型、参数个数或参数顺序上有多不同函数重载　　所谓函数重载是指同一个函数名可以对应着多个函数的实现。例如，可以给函数名add()定义多个函数实现，该函数的功能是求和，即求两个操作数的和。其中，一个函数实现是求两个int型数之和，另一个实现是求两个浮点型数之和，再一个实现是求两个复数的和。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数
【C++】函数重载及实现原理
Lin5200000的博客
04-27 2193
10分钟教你函数重载的使用及它的实现原理
1分钟了解C++运算符重载的基本原理和使用
大道至简，求同存异
03-20 344
详细的介绍C++运算符重载的定义应用及注意事项。
C++运算符重载详解
热门推荐
qq_52905520的博客
10-06 2万+
C++运算符重载详解
C++运算符的重载--日期类的实现
Hxbupaixu的博客
06-25 1076
在学习中,用C++编程的都知道，C++提供了一个非常强大的操作符重载机制，利用操作符重载，我们可以为我们自定义的类增加更多非常有用的功能,本文就是结合自己所学过的知识,对日期类函数进行模拟实现.目录1.Date.h2.Date.cpp2.1 GetMonthDay()2.2 IsInvalid()2.3 运算符重载=2.4 this指针2.5 运算符重载==2.6 运算符重载!=2.7 运算符重载> 2.8 运算符重载2.10 运算符重载>= ...
C++之运算符重载的简明了解其原理
navylhjjlh的博客
10-22 504
C++之运算符重载的简明了解其原理
【C++】第4章 运算符重载
Akiiiira的博客
06-29 195
如果不做特殊处理，C++的 “+” 、 “-” 、 “*” 、 “/” 等运算符还能用于对基本类型的常量或者变量进行运算，不能用于对象之间的运算。有时候希望对象之间也能用这些运算符进行运算，以达到使程序更简洁、易懂的目的。例如分数、复数的计算。利用C++提供的“运算符重载”机制，赋予运算符新的功能，就能解决例如用“+”将两个复数对象相加这样的问题。运算符重载，就是对已有的运算符赋予多重含义，使同一运算符作用于不同类型的数据时产生不同的行为。运算符重载的目的是使得C++中的运算符也能够用来操作对象。
【C++】运算符重载 | 赋值运算符重载
2301_76540463的博客
08-20 1953
1.常用的操作符有：+、-、*、/、++、--、=（赋值）、==（判断相等）、>、=、
C++ std::thread重载函数
最新发布
08-23
C++ std::thread重载函数是指使用std::thread库创建多线程的函数可以重载。这意味着可以根据函数的参数类型和个数的不同来区分和识别不同的重载函数。当我们在创建std::thread对象时，可以使用static_cast来转换成...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值