【CPP】函数重载、模版

于 2023-10-24 21:17:29 发布
阅读量962 收藏
点赞数
分类专栏： CPP 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38362786/article/details/134016816
版权

1-Default Arguments

Default arguments

  • A feature in C++ (not C)
  • To call a function without providing one or more trailing arguments

default-argument.cpp

#include <iostream>
#include <cmath>
using namespace std;

float norm(float x, float y, float z);
float norm(float x, float y, float z = 0);
float norm(float x, float y = 0, float z);

int main()
{
    cout << norm(3.0f) << endl;
    cout << norm(3.0f, 4.0f) << endl;
    cout << norm(3.0f, 4.0f, 5.0f) << endl;
    return 0;
}

float norm(float x, float y, float z)
{
    return sqrt(x * x + y * y + z * z);
}

在这里插入图片描述

#include <iostream>
#include <cmath>
using namespace std;

float norm(float x, float y, float z);
float norm(float x, float y = 0, float z);

int main()
{
    return 0;
}

float norm(float x, float y, float z)
{
    return sqrt(x * x + y * y + z * z);
}

在这里插入图片描述
缺失默认参数

默认参数要从尾部开始定义

重复定义默认参数也会报错:

#include <iostream>
#include <cmath>
using namespace std;

float norm(float x, float y, float z);
float norm(float x, float y, float z = 0);
float norm(float x, float y = 0, float z = 4);

int main()
{
    return 0;
}

float norm(float x, float y, float z)
{
    return sqrt(x * x + y * y + z * z);
}

在这里插入图片描述

2-Function-Overloading

Why to overload?

  • C99
<math.h>

double round (double x);
float roundf (float x);
long double roundl (long double x);
  • C++11
<cmath>

double round (double x);
float round (float x);
long double round (long double x);
  • which one do you prefer?

Function overloading

  • Which function to choose? The compiler will perform name lookup
  • Argument-dependent lookup, also known as ADL
  • The return type will not be considered in name lookup
#include <iostream>

using namespace std;

int sum(int x, int y)
{
    cout << "sum(int, int) is called" << endl;
    return x + y;
}
float sum(float x, float y)
{
    cout << "sum(float, float) is called" << endl;
    return x + y;
}
double sum(double x, double y)
{
    cout << "sum(double, double) is called" << endl;
    return x + y;
}

// //Is the following definition correct?
// double sum(int x, int y)
// {
//     cout << "sum(int, int) is called" << endl;
//     return x + y;
// }

int main()
{

    cout << "sum = " << sum(1, 2) << endl;
    cout << "sum = " << sum(1.1f, 2.2f) << endl;
    cout << "sum = " << sum(1.1, 2.2) << endl;

    //which function will be called?
    //cout << "sum = " << sum(1, 2.2) << endl;

    return 0;
}

在这里插入图片描述

//Is the following definition correct?
double sum(int x, int y)
{
    cout << "sum(int, int) is called" << endl;
    return x + y;
}

在这里插入图片描述

两个函数如果只是返回值不同，是不可以被重载的

#include <iostream>

using namespace std;

int sum(int x, int y)
{
    cout << "sum(int, int) is called" << endl;
    return x + y;
}
float sum(float x, float y)
{
    cout << "sum(float, float) is called" << endl;
    return x + y;
}
double sum(double x, double y)
{
    cout << "sum(double, double) is called" << endl;
    return x + y;
}
int main()
{

    //which function will be called?
    cout << "sum = " << sum(1, 2.2) << endl;

    return 0;
}

在这里插入图片描述

参数可以匹配多个函数，有歧义，报错

#include <iostream>

using namespace std;

int sum(int x, int y)
{
    cout << "sum(int, int) is called" << endl;
    return x + y;
}

int main()
{

    //which function will be called?
    cout << "sum = " << sum(1, 2.2) << endl;

    return 0;
}

在这里插入图片描述

warning: implicit conversion from 'double' to 'int' changes value from 2.2 to 2 [-Wliteral-conversion]
    cout << "sum = " << sum(1, 2.2) << endl;
                        ~~~    ^~~
1 warning generated.

进行了隐式类型转换

在这里插入图片描述

3-Function Templates

Why function templates

  • The definitions of some overloaded functions may be similar

Explicit Instantiation

  • A function template is not a type, or a function, or any other entity
  • No code is generated from a source file that contains only template definitions
  • The template arguments must be determined, then the compiler can generate an actual function

实例化

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x +
     y;
}
// Explicitly instantiate
template double sum<double>(double, double);

// instantiates sum<char>(char, char), template argument deduced
template char sum<>(char, char);

// instantiates sum<int>(int, int), template argument deduced
template int sum(int, int);

template1.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x +
     y;
}
// Explicitly instantiate
template double sum<double>(double, double);

int main()
{
    auto val = sum(4.1, 5.2);
    cout << val << endl;
    return 0;
}


The input type is d
9.3

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x +
     y;
}
// Explicitly instantiate
template float sum<float>(float, float);

int main()
{
    auto val = sum(4.1, 5.2);
    cout << val << endl;
    return 0;
}


The input type is d
9.3

为什么还是调用了类型为double的函数？

为什么把函数删掉依然能够编译？

其实是因为函数可以做隐式实例化

Implicit Instantiation

  • Implicit instantiation occurs when a function template is not explicitly instantiated

隐式实例化

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x + y;
}
// Implicitly instantiates product<int>(int, int)
cout << "sum = " << sum<int>(2.2f, 3.0f) << endl;
// Implicitly instantiates product<float>(float, float)
cout << "sum = " << sum(2.2f, 3.0f) << endl;

template2.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x + y;
}

int main()
{
    // Implicitly instantiates product<int>(int, int)
    cout << "sum = " << sum<int>(2.2f, 3.0f) << endl;
    // Implicitly instantiates product<float>(float, float)
    cout << "sum = " << sum(2.2f, 3.0f) << endl;

    return 0;
}


sum = The input type is i
5
sum = The input type is f
5.2

Function template specialization

  • We have a function template
template<typename T> T sum(T x, T y)
  • If the input type is Point
struct Point
{
  int x;
  int y;
};
  • But no + operator for Point;
  • We need to give a special definition for this case

specialization.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x + y;
}

struct Point
{
    int x;
    int y;
};


int main()
{
    //Explicit instantiated functions
    cout << "sum = " << sum(1, 2) << endl;
    cout << "sum = " << sum(1.1, 2.2) << endl;

    Point pt1 {1, 2};
    Point pt2 {2, 3};
    Point pt = sum(pt1, pt2);
    cout << "pt = (" << pt.x << ", " << pt.y << ")" << endl;
    return 0;
}

specialization.cpp:9:14: error: invalid operands to binary expression ('Point' and 'Point')
    return x + y;
           ~ ^ ~
specialization.cpp:38:16: note: in instantiation of function template specialization 'sum<Point>' requested here
    Point pt = sum(pt1, pt2);

不合法的操作

专门去定义Point结构体模版

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename T>
T sum(T x, T y)
{
    cout << "The input type is " << typeid(T).name() << endl;
    return x + y;
}

struct Point
{
    int x;
    int y;
};

// Specialization for Point + Point operation
template<>
Point sum<Point>(Point pt1, Point pt2)
{
    cout << "The input type is " << typeid(pt1).name() << endl;
    Point pt;
    pt.x = pt1.x + pt2.x;
    pt.y = pt1.y + pt2.y;
    return pt;
}


int main()
{
    //Explicit instantiated functions
    cout << "sum = " << sum(1, 2) << endl;
    cout << "sum = " << sum(1.1, 2.2) << endl;

    Point pt1 {1, 2};
    Point pt2 {2, 3};
    Point pt = sum(pt1, pt2);
    cout << "pt = (" << pt.x << ", " << pt.y << ")" << endl;
    return 0;
}


sum = The input type is i
3
sum = The input type is d
3.3
The input type is 5Point
pt = (3, 5)

如果只是template 是实例化，如果加了template<> 是特例化。

4- Function Pointers and References

Function pointers

  • norm_ptr is a pointer, a function pointer
  • The function should have two float parameters, and returns float
#include <iostream>
#include <cmath>
using namespace std;

float norm_l1(float x, float y); //declaration
float norm_l2(float x, float y); //declaration
float (*norm_ptr)(float x, float y); //norm_ptr is a function pointer

int main()
{
    norm_ptr = norm_l1; //Pointer norm_ptr is pointing to norm_l1
    cout << "L1 norm of (-3, 4) = " << norm_ptr(-3.0f, 4.0f) << endl;

    norm_ptr = &norm_l2; //Pointer norm_ptr is pointing to norm_l2
    cout << "L2 norm of (-3, 4) = " << (*norm_ptr)(-3.0f, 4.0f) << endl;

    return 0;
}

float norm_l1(float x, float y)
{
    return fabs(x) + fabs(y);
}

float norm_l2(float x, float y)
{
    return sqrt(x * x + y * y);
}

L1 norm of (-3, 4) = 7
L2 norm of (-3, 4) = 5

函数指针：指向函数的指针，要求指向的函数要跟指针的类型完全相同，也就是说指针指向的函数应该要有两个参数，且这两个参数的类型都应该是float，返回值也是float

  • A function pointer can be an argument and pass to a function
<stdlib.h>

void qsort(void *ptr, size_t count,  size_t size, int(*comp)(const void*, const void*));
  • To sort some customized types, such as
struct Point
struct Person

Function references

function-reference.cpp

#include <iostream>
#include <cmath>
using namespace std;

float norm_l1(float x, float y); //declaration
float norm_l2(float x, float y); //declaration
float (&norm_ref)(float x, float y) = norm_l1; //norm_ref is a function reference

int main()
{
    cout << "L1 norm of (-3, 4) = " << norm_ref(-3, 4) << endl;
    return 0;
}

float norm_l1(float x, float y)
{
    return fabs(x) + fabs(y);
}

float norm_l2(float x, float y)
{
    return sqrt(x * x + y * y);
}

L1 norm of (-3, 4) = 7

5- Recursive Functions

Recursive Functions

  • A simple example

recursion.cpp

#include <iostream>
using namespace std;

void div2(double val);

int main()
{
    div2(1024.); // call the recursive function
    return 0;
}

void div2(double val)
{

    cout << "Entering val = " << val << endl;
    if (val > 1.0)
        div2( val / 2); // function calls itself
    else
        cout << "--------------------------" << endl;
    
    cout << "Leaving  val = " << val << endl;
}


Entering val = 1024
Entering val = 512
Entering val = 256
Entering val = 128
Entering val = 64
Entering val = 32
Entering val = 16
Entering val = 8
Entering val = 4
Entering val = 2
Entering val = 1
--------------------------
Leaving  val = 1
Leaving  val = 2
Leaving  val = 4
Leaving  val = 8
Leaving  val = 16
Leaving  val = 32
Leaving  val = 64
Leaving  val = 128
Leaving  val = 256
Leaving  val = 512
Leaving  val = 1024
  • Pros:
  1. Good at tree traversal
  2. Less lines of source code
  • Cons:
  1. Consume more stack memory
  2. May be slow
  3. Difficult to implement and debug
LAWKAWAI
关注
专栏目录
编译报错：error: implicit conversion from enumeration type ‘enum _BT_OPCODE_STATUS‘ to different enum
Android系统开发笔记
07-12 2068
这个错误信息通常出现在将一个枚举类型隐式转换为另一个枚举类型时。由于不同的枚举类型可能具有不同的值，这种转换可能会导致意外的错误。要解决这个错误，您需要显式地将一个枚举类型转换为另一个枚举类型，或者将枚举类型的值映射到另一个枚举类型的值。如果您无法使用显式转换，可以将枚举类型的值映射到另一个枚举类型的值。这将告诉编译器忽略枚举类型转换的警告，并继续编译程序。如果您确信枚举类型的转换是安全的，并且您需要在代码中保留它，请使用。在这个例子中，错误是由于将一个枚举类型。的值设置为相应的值。
CPP {模板函数,可变长模板函数,函数模板特化}
最新发布
qq_66485519的博客
04-23 220
2
13.1 Implicit conversions
★★创造未来★★
12-11 1407
13.1 Implicit conversionsThe following conversions are classified as implicit conversions:?Identity conversions?Implicit numeric conversions?Implicit enumeration conversions.?Implicit reference conver
c++学习--类型初始化时防止类型收窄
u010029439的博客
06-10 967
参考：https://blog.csdn.net/hailong0715/article/details/54018002
C++Primer第五版 第二章练习
Paul_Huang的专栏
09-03 1964
2.1.1节练习练习2.1: 类型int ,long ,long long 和 short的区别是什么？无符号类型和带符号类型的区别是什么？float和double的区别是什么？练习2.2：计算按揭贷款时，对于利率、本金和付款分别应选择何种数据类型？说明你的理由。答： 2.1 int 是整形 ，最小尺寸16位。 long 是长整形，32位; long long 也是长整型 最小尺
cpp代码-函数模板和函数重载调用规则
07-14
在C++编程语言中，函数模板和函数重载是两种重要的多态实现方式，它们极大地增强了代码的灵活性和可复用性。本文将深入探讨这两个概念及其调用规则。 首先，我们来理解函数模板。函数模板是一种通用的函数定义方式...
C++函数重载的深入解析
09-05
在C++编程语言中，函数重载（Function Overloading）是一项关键特性，它允许程序员使用同一个函数名来实现不同功能，但这些功能必须通过不同的参数列表来区分。函数重载的核心在于编译器如何根据传入的参数类型和...
char int 转换不允许
HouYing
12-28 2444
sybase    websphere    linuxImplicit conversion from datatype CHAR to INT is not allowed.  Use the CONVERT function to run this query.ibatis中如果对于数据库中的字段类型为int 那么查询中传递的参数也应该是整数executeQueryForOb
C语言的隐式类型转换的规则——从第一手信源（C的标准）入手
swimmingfish2004的专栏
04-10 698
一：C89 原文： 3.2 CONVERSIONS Several operators convert operand values from one type to another automatically. This section specifies the result required from such an implicit conversion, as wel...
MPLAB编译错误:implicit conversion of float to integer
Embedded Travel
06-05 3914
用MPLAB编译程序，正在心里祈祷千万不要出现FAILED,结果FAILED还是出来了，害我想半天，以前碰到过一次这个错误，当时解决后想着也不是典型问题，就懒得记了，导致这次遇到同样问题，浪费时间在做重复工作上，事儿虽小，却提醒我，在写程序的过程中，一定要注意总结，注意积累，不可只盯着眼前的程序调试通过就OK。 编译提示错误指定在行： dat=(dat2*256+dat1)*(0.0625*1
【私人系列】日常PHP遇到的各种稀奇古怪的问题
暂时先用这个名字
07-30 776
在日常维护或开发时，遇到的各种php问题，总结一下，相信自己下次还会遇到~~~~
c语言变量类型和范围_C变量和类型
cuk0051的博客
08-28 1429
c语言变量类型和范围C is a statically typed language. C是一种静态类型的语言。 This means that any variable has an associated type, and this type is known at compilation time. 这意味着任何变量都具有关联的类型，并且该类型在编译时是已知的。 This is ...
PyTorch编写代码遇到的问题
flyfish
03-03 1万+
训练人脸检测mtcnn遇到的问题 flyfish no module named xxx xxx为自定义文件夹的名字 因为搜索不到，所以将当前路径加入到包的搜索目录 解决方法： import sys sys.path.append(’…’) #将上层目录加入到搜索路径中 sys.path.append(’/home/xxx’) # 绝对路径 import os sys.path.append(os...
C语言 cannot convert 'float' to 'float*' for argument '1' to 'float average
SkYe's Blog
07-14 2万+
示例错误代码 #include<stdio.h> int main() { float max(float array[],n); float a[5]={1,2,3,4,5}; printf("the max number is %d\n",max(a[5]); } //函数定义部分不重要。只是用作示例。 float max(float array[],n) { int i,...
keil5编写stm32代码：提示single-precision operand implicity converted to double-precesion
热门推荐
junyilao的博客
04-23 2万+
  使用keil5编写stm32代码，编译提示single-precision operand implicity converted to double-precesion，意思是单精度运算隐式转换成双精度运算了，可以忽略这个警告，也可以在所有的浮点数字后面加上f,警告就会消失。比如:float a=0.4f,b=0.0f;b=10.0f*5*a;这样就不会出现这个警告了，注意一定在所有的浮点数...
C++函数重载、模板详解：提升编程效率
本文档主要介绍了C++中的三个关键概念：函数重载、函数模板和类模板，这些概念是面向对象编程的重要组成部分。 一、函数重载 函数重载是C++允许在同一个作用域内，使用相同的函数名定义多个具有不同参数列表的函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值