C++函数重载

合集下载

C++基础系列——运算符重载

C++基础系列——运算符重载

C++基础系列——运算符重载1. 运算符重载简介所谓重载,就是赋予新的含义。

函数重载(Function Overloading)可以让⼀个函数名有多种功能,在不同情况下进⾏不同的操作。

同样运算符重载(Operator Overloading)可以让同⼀个运算符可以有不同的功能。

可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符,⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载:class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数,在函数体内实现想要的功能,当⽤到该运算符时,编译器会⾃动调⽤这个函数,它本质上是函数重载。

C++考试重点

C++考试重点

C++考试重点一、选择题1.关于函数重载:AA.两个或两个以上的函数取相同的函数名,但形参的个数或类型不同B.两个以上的函数取相同的名字和具有相同的参数个数,但形参的类型可以不同C两个以上的函数名字不同,但形参的个数或类型相同. D.两个以上的函数取相同的函数名,并且函数的返回类型相同2. 关于引用:A. 每一个引用都是其所引用对象的别名,因此必须初始化VB . 形式上针对引用的操作实际上作用于它所引用的对象VC . 一旦定义了引用,一切针对其所引用对象的操作只能通过该引用间接进行XD. 不需要单独为引用分配存储空间V3. 关于封装,BA . 通过封装,对象的全部属性和操作结合在一起,形成一个整体B. 通过封装,一个对象的实现细节被尽可能地隐藏起来(不可见)C.通过封装,每个对象都成为相对独立的实体D. 通过封装,对象的属性都是不可见的4. 判断A派生类的对象可以赋给基类的对象 VB.派生类的对象可以初始化基类的引用 VC.派生类的对象可以直接访问基类中的成员 XD .派生类的对象的地址可以赋给指向基类的指针V5.对于类定义Class {public:virtual void funy( ){ }void funx( ){ }}class B:public m{public:void funy( ){cout<<〃class B func 1〃<<end1;}virtual void funx( ){cout<<〃class B func 2〃<<end1;}};判断下列说法是否正确?C对A. M::funx( )和B::funy( )都是虚函数B、M::funx( )和B::funy( )都不是虚函数C、 B::funy( )是虚函数,而M::funx( )不是虚函数 VD、B::funy( )不是虚函数,而M::funx( )是虚函数6 对于char* kk[7];的描述,()是正确的。

C 的高级特性---函数重载,重写,覆盖

C  的高级特性---函数重载,重写,覆盖
示例8-1-1 重载函数Eat
C++语言采用重载机制的另一个理由是:类的构造函数需要重载机制。因为C++规定构造函数与类同名(请参见第9章),构造函数只能有一个名字。如果想用几种不同的方法创建对象该怎么办?别无选择,只能用重载机制来实现。所以类可以有多个同名的构造函数。
8.1.2 重载是如何实现的?
int x = Function ();
则可以判断出Function是第二个函数。问题是在C++/C程序中,我们可以忽略函数的返回值。在这种情况下,编译器和程序员都不知道哪个Function函数被调用。
所以只能靠参数而不能靠返回值类型的不同来区分重载函数。编译器根据参数为每个重载函数产生不同的内部标识符。例如编译器为示例8-1-1中的三个Eat函数产生象_eat_beef、_eat_fish、_eat_chicken之类的内部标识符(不同的编译器可能产生不同风格的内部标识符)。
{
void foo(int x, int y);
… // 其它函数
}或者写成
extern “C”
{
#include “myheader.h”
… // 其它C头文件
}
这就告诉C++编译译器,函数foo是个C连接,应该到库中找名字_foo而不是找_foo_int_int。C++编译器开发商已经对C标准库的头文件作了extern“C”处理,所以我们可以用#include 直接引用这些头文件。注意并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算重载,因为函数的作用域不同。例如:
示例8-2-1中,函数Base::f(int)与Base::f(float)相互重载,而Base::g(void)被Derived::g(void)覆盖。

c 函数重载 方法

c 函数重载 方法

c 函数重载方法
C函数重载是C语言中一种非常有用的编程技术,它允许我们定义多个具有相同名称但参数列表不同的函数。

通过函数重载,我们可以使用相同的函数名来执行不同的操作,这样可以提高代码的可读性和灵活性。

在C语言中,函数重载是通过函数名相同但参数列表不同来实现的。

当调用一个重载函数时,编译器会根据传入的参数类型和数量来决定调用哪个函数。

这样,我们可以根据需要定义多个具有相同函数名但不同参数列表的函数,从而实现函数重载。

函数重载在C语言中有许多应用场景,比如实现不同类型的输入参数、返回不同类型的值、实现相似但不完全相同的功能等。

通过函数重载,我们可以更加灵活地使用函数,提高代码的复用性和可维护性。

总之,C函数重载是一种非常有用的编程技术,它可以帮助我们更好地组织和管理代码,提高代码的可读性和灵活性。

在实际开发中,我们可以根据需要合理地使用函数重载,从而更好地实现我们的编程目标。

c语言中 所有函数用法

c语言中 所有函数用法

c语言中所有函数用法在C语言中,函数是程序的基本构建块之一。

以下是C语言中一些常见的函数用法:1. 函数的定义:```c// 函数原型声明int add(int a, int b);// 函数定义int add(int a, int b) {return a + b;}```2. 函数的调用:```cint result = add(3, 4);```3. 函数参数传递方式:-按值传递:```cvoid modifyValue(int x) {x = 10;}int main() {int num = 5;modifyValue(num);// num 的值仍然是5,因为modifyValue 中的修改不影响原始值return 0;}```-按引用传递:```cvoid modifyValue(int *x) {*x = 10;}int main() {int num = 5;modifyValue(&num);// num 的值现在是10,因为modifyValue 中通过指针修改了原始值return 0;}```4. 函数返回值:```cint add(int a, int b) {return a + b;}int main() {int result = add(3, 4);// result 的值为7return 0;}```5. 函数多参数:```cfloat calculateAverage(int num1, int num2, int num3) {return (num1 + num2 + num3) / 3.0;}int main() {float avg = calculateAverage(10, 20, 30);// avg 的值为20.0return 0;}```6. 函数重载(C语言不支持函数重载):C语言本身不支持函数重载。

如果你需要实现类似功能,可以使用不同的函数名或者使用默认参数。

C++函数重载实现方法剖析

C++函数重载实现方法剖析
维普资讯
宝鸡文理学 院学报 ( 自然科学 版) 第 2 . 2期 , 1 617页 ,0 6年 6月 , 6卷 第 第 5 —6 20
J u n l f a j Unv r i f t n c n e Nau a S i c ) voI 6 N . ・ P 1 6 1 7 J r 2 0 o r a o oi i s yo sa dS i cs( tr l c n e , l , o 2 P . 5 — 5 ,u 0 6 B e t Ar e e 2 a
制 的关键 , 也是 实现 C + 中类型安 全 的链 接 的特 征 的基 础 , 以利 用该 实现 策略 对 C语 言 中函数 的相 + 可 关语 法进 行 解释 。 关键 词 : 函数 重 栽 ; 名字 冲 突; 改名 中 图分 类号 : P 1 T 3 文 献标 识 码 : A 文章 编 号 :0 71 6 (0 6 0 —1 60 1 0 -2 1 2 0 ) 20 5 —2
Ke r s f n to v ro d; a o fit F me ma g i g y wo d : u c i n o e l a n me c n l ; l n l c a n
A a s f ++ fnt noel di l ett n nl io ys C uc o vr a e nai i o mp m o
ZH ANG e b W n- o ( p.C mp c i De t o .S .,Baj Unv oi i.Ars& S i ,B oi 2 0 7,S a n i t c. a j 7 1 0 h a x,Chn ) i a
d to h tc ry o tt p —ae yl kn , a k s ft a ta e yt a r ne pan t h ea — a in t a a r u y e s ft n ig c n ma eu eo h tsr tg oc r yo x li ot erlt i e h a i g o h u cin i h a g a e d p r sn ft ef n to n t eC ln u g .

c语言函数调用例子

c语言函数调用例子

c语言函数调用例子函数调用是C语言中常用的一种语法结构,通过函数调用可以实现代码的模块化和复用。

下面列举了十个不同的C语言函数调用的例子,以展示函数调用的不同用法和特点。

1. 系统库函数的调用系统库函数是C语言提供的一些常用函数,可以直接调用来完成一些常见的操作。

例如,可以使用printf函数来输出字符串到标准输出:```c#include <stdio.h>int main() {printf("Hello, World!\n");return 0;}```2. 自定义函数的调用除了系统库函数,我们也可以自己定义函数来实现特定的功能。

例如,可以定义一个函数来计算两个整数的和,并在主函数中调用该函数:```c#include <stdio.h>int add(int a, int b) {return a + b;}int main() {int a = 3, b = 5;int sum = add(a, b);printf("The sum of %d and %d is %d\n", a, b, sum);return 0;}```3. 函数的递归调用递归是一种函数调用自身的方法,可以解决一些需要重复执行的问题。

例如,可以使用递归函数来计算斐波那契数列的第n项:```c#include <stdio.h>int fibonacci(int n) {if (n <= 1) {return n;} else {return fibonacci(n - 1) + fibonacci(n - 2);}}int main() {int n = 10;int result = fibonacci(n);printf("The %dth Fibonacci number is %d\n", n, result);return 0;}```4. 函数的多次调用一个函数可以被多次调用,每次调用可以传入不同的参数。

详解C++编程中的重载流插入运算符和流提取运算符

详解C++编程中的重载流插入运算符和流提取运算符

详解C++编程中的重载流插⼊运算符和流提取运算符C++的流插⼊运算符“<<”和流提取运算符“>>”是C++在类库中提供的,所有C++编译系统都在类库中提供输⼊流类istream和输出流类ostream。

cin和cout分别是istream类和ostream类的对象。

在类库提供的头⽂件中已经对“<<”和“>>”进⾏了重载,使之作为流插⼊运算符和流提取运算符,能⽤来输出和输⼊C++标准类型的数据。

因此,凡是⽤“cout<<”和“cin>>”对标准类型数据进⾏输⼊输出的,都要⽤#include 把头⽂件包含到本程序⽂件中。

⽤户⾃⼰定义的类型的数据,是不能直接⽤“<<”和“>>”来输出和输⼊的。

如果想⽤它们输出和输⼊⾃⼰声明的类型的数据,必须对它们重载。

对“<<”和“>>”重载的函数形式如下:istream & operator >> (istream &, ⾃定义类 &);ostream & operator << (ostream &, ⾃定义类 &);即重载运算符“>>”的函数的第⼀个参数和函数的类型都必须是istream&类型,第⼆个参数是要进⾏输⼊操作的类。

重载“<<”的函数的第⼀个参数和函数的类型都必须是ostream&类型,第⼆个参数是要进⾏输出操作的类。

因此,只能将重载“>>”和“<<”的函数作为友元函数或普通的函数,⽽不能将它们定义为成员函数。

重载流插⼊运算符“<<”在程序中,⼈们希望能⽤插⼊运算符“<<”来输出⽤户⾃⼰声明的类的对象的信息,这就需要重载流插⼊运算符“<<”。

[例] ⽤重载的“<<”输出复数。

c语言实现函数重载模板

c语言实现函数重载模板

c语言实现函数重载模板摘要:1.函数重载的定义和意义2.C 语言中的函数重载3.函数重载的实现方法4.函数重载的模板5.函数重载的示例正文:【1.函数重载的定义和意义】函数重载是指在同一个作用域内,允许存在多个同名函数,但是这些函数的参数列表必须不同,也就是说,它们的函数签名必须不同。

函数重载的意义在于,它可以提高程序的运行效率,使得程序的代码更加简洁易懂。

【2.C 语言中的函数重载】在C 语言中,函数重载是通过使用不同的参数列表来实现的。

这意味着,如果两个函数具有相同的函数名,但是它们的参数列表不同,那么这两个函数就是重载函数。

【3.函数重载的实现方法】实现函数重载的方法非常简单,只需要在函数名相同的情况下,改变函数的参数列表即可。

这样,编译器就可以根据参数列表的不同,来区分并正确调用不同的函数。

【4.函数重载的模板】下面是一个函数重载的模板:```C#include <stdio.h>int add(int x, int y);int add(int x, int y, int z);int main() {int a, b, c;printf("请输入两个整数:");scanf("%d%d", &a, &b);printf("%d+%d=", a, b);add(a, b);printf("");printf("请输入三个整数:");scanf("%d%d%d", &a, &b, &c);printf("%d+%d+%d=", a, b, c);add(a, b, c);return 0;}int add(int x, int y) {return x + y;}int add(int x, int y, int z) {return x + y + z;}```【5.函数重载的示例】在上面的代码中,我们定义了两个同名函数add,但是它们的参数列表不同。

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解三种重载⽅式⾸先,介绍三种重载⽅式:1//作为成员函数重载(常见)2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时,*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载(不推荐)2class Person{3public://注意,重载运算符为普通函数时,使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种:bool Person::operator<(const Person& b),bool是函数返回类型,Person::只是指定了成员函数所属类名。

c不能重载的运算符 -回复

c不能重载的运算符 -回复

c不能重载的运算符-回复c语言中有一些运算符是无法进行重载的,即无法改变其原有的语义和操作方式。

这些不能重载的运算符包括以下几种:1. 赋值运算符(=):赋值运算符是最基本的运算符之一,用于将一个值赋给变量。

在C中,赋值运算符是不可重载的,其行为无法进行改变。

这是因为赋值运算符的语义已经由语言规范明确定义,重载赋值运算符可能会导致代码的可读性和可维护性降低。

2. 成员访问运算符(.和->):成员访问运算符用于访问结构体或类的成员变量和成员函数。

在C中,这两个运算符也是不可重载的。

这是因为结构体和类的成员布局是由编译器处理的,重载这两个运算符可能会导致无法正确访问成员变量和成员函数。

3. 下标运算符([]):下标运算符用于访问数组或类的重载了下标运算符的对象的元素。

在C中,下标运算符也是不可重载的。

这是因为C语言的数组和类似数组的结构体没有内置的下标处理机制,重载下标运算符可能会导致访问越界或者出现其他意想不到的问题。

4. 函数调用运算符(()):函数调用运算符用于调用函数或重载了函数调用运算符的对象的操作符函数。

在C中,函数调用运算符也是不可重载的。

这是因为C语言的函数调用机制是由编译器和操作系统处理的,重载函数调用运算符可能会导致无法正确调用函数或者出现其他问题。

5. 三个由语言规范定义的运算符:sizeof、?:和. (点操作符):这三个运算符有特定的语法和语义,无法进行重载。

sizeof运算符用于获取类型或对象的大小,?:运算符用于条件选择,点操作符用于访问成员变量或成员函数。

上述的这些运算符在C语言中是不可变的,它们的行为由语言规范明确定义,并且编译器对其进行了特殊处理。

重载这些运算符可能会导致代码的不可预测行为和难以维护的错误。

因此,C语言中禁止对这些运算符进行重载。

对于需要对这些运算符进行自定义操作的需求,可以使用其他方法来实现,如使用函数或宏来替代运算符的功能。

此外,在其他编程语言中,如C++和Java,一些运算符是可以进行重载的,开发者可以根据自己的需求对运算符进行自定义操作。

C 程序设计(谭浩强完整版)运算符重载

C  程序设计(谭浩强完整版)运算符重载
第十三章
运算符重载
1
函数的重载 所谓函数的重载是指完成不同功能的函数可以具 有相同的函数名。 C++的编译器是根据函数的实参来确定应该调用 哪一个函数的。
int fun(int a, int b) void main(void) { cout<<fun(3,5)<<endl; cout<<fun(5)<<endl; }
由这个函数来完成该运算符应该完成的操作。这 种函数称为运算符重载函数,它通常是类的成员 函数或者是友元函数。运算符的操作数通常也应 该是类的对象。
6
重载为类的成员函数
格式如下:
关键字 <类名> operator<运算符>(<参数表>)
{ 函数体 } 函数名 运算的对象
运算的对象
返回类型
A operator + (A &);
15
class A { int i; public:A(int a=0){ i=a; } void Show(void){ cout<<"i="<<i<<endl; } A operator +(A &a) //重载运算符+ { A t; t.i=i+a.i; return t; } void operator+=(A &a) { i=i+a.i; } 由左操作符调用右操 }; 作符,没有返回值, void main(void) 故函数类型为void。 { A a1(10),a2(20),a3; a1.Show (); a2.Show (); 相当于a3=a1.operator+(a2) a3=a1+a2; a1+=a2; 相当于a1.operator+=(a2) a3.Show (); }

c语言 函数重载

c语言 函数重载

c语言函数重载1 什么是C语言函数重载C语言函数重载是指拥有相同名字,但是参数类型和/或者参数数量不同的多个函数。

它是采用多态思想而发明的一种在C语言中实现的函数多态技术,支持函数的重载,使得C语言也具备多态特性,这使得程序设计更加灵活,并且减少了代码量。

2 C语言函数重载的实现方式C语言支持函数重载的实现方式有两种:1) 通过函数的参数列表(参数的类型和参数的个数)进行区分2) 通过宏(#define)预处理指令第一种方式是通过将函数的参数列表(即参数的类型和个数)来区分,这种实现方式也称为编译时表示,即在编译器对源代码进行完编译处理后,就可以决定具体调用哪一个函数了。

第二种方式是通过宏(#define)预处理指令,这种方式相对于第一种方式来说实现起来更加简单,只需要在编译器将源代码完成标识符的替换后就可以实现函数的重载。

3 C语言函数重载的优缺点实现函数重载的优点如下:(1)简化程序设计能够在程序设计中使用一个函数名称来实现多种不同的功能,减少了函数名称的污染,更加容易理解和控制程序,使程序变得更加简洁、优雅。

(2)代码共享利用同一个函数名可以用于不同的参数,可以对通用的代码共享利用,节省了大量的空间。

因此函数重载可以减少重复的代码,提高代码的复用,降低程序的体积,降低编译的复杂度。

但是,C语言函数重载也有其缺点:(1)容易造成混淆如果函数的参数列表中参数的数量是相同的,但是参数类型却有所不同,这样在编写程序时容易造成混淆,难以理解程序的执行逻辑,在调试和维护过程中也增加了负担。

(2)函数指针在C语言中,函数指针作为一个变量处理,无法使用函数重载的特性,从而影响程序的可移植性。

4 结论C语言支持函数重载,实现函数重载可以在C语言中实现函数的多态性,给程序设计提供了便利,能够提高用户体验,但同时也需要注意其所带来的问题。

C语言为什么不支持重载

C语言为什么不支持重载

首先这个问题的答案是C++支持函数重载而C语言不支持函数重载。

下面我们从程序编译链接阶段看看其中的原因。

先看看重载的定义,函数重载就是指:
在同一作用域类,一组函数的函数名相同,参数列表不同(个数不同或类型不同),返回值可同可不同。

那么问题来了,为什么C++支持函数重载,而C语言不支持呢?
从代码的编译到运行,在VC6.0或VS这种编译器下,它是系统直接完成了翻译与链接,直接生成了运行结果。

编译器内部完成了翻译部分:
1.预处理
1)头文件展开
2)宏的替换
3)去注释
4)条件编译
2.编译过程:将高级语言转为汇编语言;
3.汇编过程:汇编语言转为二进制程序;
4.链接部分:所引用的数据链接进来。

比如一个函数的声明如下:
void function(int x,int y);
在c语言中,编译器在编译后在库中的名字为_function
在c++中,编译器在编译后在库中的名字为_function_int_int
还有一个函数的声明如下:
void function(float x,float y);
在c语言中,编译器在编译后在库中的名字为_function。

而在c++中,编译器在编译后在库中的名字为_function_float_float。

在链接时,都是找名字进行链接的,就比如以上两个函数,在C语言中两个的名字一样,就会在链接中报错。

C++中它们的名字不一样,所以就不会报错。

c语言同名函数范文

c语言同名函数范文

c语言同名函数范文C语言是一种面向过程的编程语言,它提供了许多同名函数,即函数名相同但参数列表不同的函数。

这些同名函数在C语言中被称为函数重载。

函数重载是一种函数多态性的体现,它允许在同一个作用域中定义多个同名函数,这些函数可以拥有不同的参数列表,当调用该函数时,编译器根据实际参数的类型、个数、顺序等,自动选择匹配的函数进行调用。

以下是C语言中常见的同名函数:1. printf函数:printf函数用于将字符串或其他数据格式化输出到标准输出设备。

根据格式字符串的不同,可以重载多个printf函数。

例如,printf("%d", num)用于打印整数,printf("%f", num)用于打印浮点数,printf("%s", str)用于打印字符串等。

2. scanf函数:scanf函数用于从标准输入设备读取格式化数据。

根据参数的不同,可以重载多个scanf函数。

例如,scanf("%d", &num)用于读取整数,scanf("%f", &num)用于读取浮点数,scanf("%s", str)用于读取字符串等。

3. atoi函数和atof函数:atoi函数将字符串转换为整数,atof函数将字符串转换为浮点数。

这两个函数都具有同名的特性,但参数和返回值类型不同。

4. strcmp函数和strncmp函数:strcmp函数用于比较两个字符串的大小,strncmp函数用于比较两个指定长度的字符串的大小。

它们的同名特性体现在函数名上,但参数和返回值类型不同。

5. malloc函数和calloc函数:malloc函数用于在堆上分配一块指定大小的内存空间,calloc函数用于在堆上分配一块指定大小且初始化为0的内存空间。

这两个函数具有同名特性,但参数和返回值类型不同。

6. pow函数和fabs函数:pow函数用于计算x的y次幂,fabs函数用于计算x的绝对值。

c语言 重载 赋值运算符

c语言 重载 赋值运算符

c语言重载赋值运算符【原创版】目录1.概述 C 语言中的运算符重载2.赋值运算符重载的规则和注意事项3.示例:实现一个简单的赋值运算符重载正文一、概述 C 语言中的运算符重载C 语言是一种广泛应用的编程语言,其功能丰富,可以实现各种复杂的操作。

在 C 语言中,运算符重载是一种重要的语言特性,它允许程序员根据需要自定义运算符的行为。

运算符重载可以让代码更加简洁,提高程序的可读性。

在 C 语言中,赋值运算符重载是最常用的一种运算符重载方式。

二、赋值运算符重载的规则和注意事项赋值运算符重载是指对 C 语言中的赋值运算符“=”进行重载,以实现特定的功能。

在实现赋值运算符重载时,需要遵循以下规则:1.运算符重载函数必须有一个参数,即要赋值的对象。

2.运算符重载函数不能有返回值。

赋值运算符的功能是将右侧表达式的值赋给左侧的对象,因此不能有返回值。

3.运算符重载函数的函数名以“operator”开头,后跟赋值运算符“=”。

例如,实现一个整数类型的赋值运算符重载,函数名应为“operator=”。

4.在运算符重载函数中,不能修改左侧的对象。

只能通过拷贝构造函数或赋值运算符来修改对象的值。

5.运算符重载函数的参数类型必须与左侧对象的类型匹配。

三、示例:实现一个简单的赋值运算符重载下面是一个简单的示例,实现了一个整数类型的赋值运算符重载。

在这个示例中,我们定义了一个名为“Int”的整数类,并在其中实现了赋值运算符重载。

```c#include <iostream>using namespace std;class Int {public:// 构造函数Int(int value) {this->value = value;}// 拷贝构造函数Int(const Int& other) {this->value = other.value;}// 重载赋值运算符void operator=(const Int& other) {if (this == &other) {return; // 禁止自我赋值}this->value = other.value;}// 打印函数void print() {cout << "Value: " << value << endl;}private:int value;};int main() {Int a, b;a = 10;b = a;b = 20;a.print(); // 输出:Value: 20return 0;}```在这个示例中,我们定义了一个名为“Int”的整数类,并在其中实现了赋值运算符重载。

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。

1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。

可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。

2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。

在有关的类中把它声明为友元函数,即友元运算符重载函数。

例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。

1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。

第七章 函数的重载

第七章 函数的重载

7
实现函数重载
函数重载是通过在类中定义两个或更多的同名的函 数来实现函数重载。 数来实现函数重载。 在函数重载中, 在函数重载中,函数的每个定义必须在函数签名中 不同。 不同。
8
函数签名
函数的签名被下面的部分定义: 函数的签名被下面的部分定义:
参数的数量 参数的类型 参数的顺序 返回类型不是函数签名的一部分
public class DaysInYear { private int days; public DaysInYear(int days) 1.DaysInYear DIY = new DaysInYear(); { 2.DaysInYear DIY = new DaysInYear(5); this.days = days; 3.DaysInYear DIY = new DaysInYear("5"); } public DaysInYear(String dayOne) 4.DaysInYear DIY = new DaysInYear(‘5’); 5.DaysInYear DIY; { days =Convert.ToInt32(dayOne); } 1.错误 错误 public void setDay(int newDays) 2.调用int构造函数 调 构造函数 { 3.调用string构造函数 调 构造函数 days = newDays; 4.调用int构造函数 调 构造函数 } 5.没有对象生成,需要 没有对 或者让 没有 象生成,需要new或者让它指向一 或者 … 个DaysInYear对象 对 }
函数重载: 函数重载:这个方法允许为两个或更多函数使用同样 的名字。 的名字。函数的每个重新定义必须使用不同的参数类 参数顺序或多个参数。 型、参数顺序或多个参数。 操作符重载: 操作符重载:这个方法允许用户定义的类型例如结构 和类,为使它们的对象易于操作而使用重载操作符。 和类,为使它们的对象易于操作而使用重载操作符。

c++运算符重载注意事项

c++运算符重载注意事项

c++运算符重载注意事项注意事项:1.除了类属关系运算符"."、成员指针运算符".*"、作⽤域运算符"::"、sizeof运算符和三⽬运算符"?:"以外,C++中的所有运算符都可以重载。

2.重载运算符限制在C++语⾔中已有的运算符范围内的允许重载的运算符之中,不能创建新的运算符。

3.运算符重载实质上是函数重载,因此编译程序对运算符重载的选择,遵循函数重载的选择原则。

4.重载之后的运算符不能改变运算符的优先级和结合性,也不能改变运算符操作数的个数及语法结构。

5.运算符重载不能改变该运算符⽤于内部类型对象的含义。

它只能和⽤户⾃定义类型的对象⼀起使⽤,或者⽤于⽤户⾃定义类型的对象和内部类型的对象混合使⽤时。

6.运算符重载是针对新类型数据的实际需要对原有运算符进⾏的适当的改造,重载的功能应当与原有功能相类似,避免没有⽬的地使⽤重载运算符。

例:下列关于运算符重载的描述中,( B )是正确的。

A :运算符重载可以改变运算数的个数。

B :运算符重载可以改变优先级。

C :运算符重载可以改变结合性。

D :运算符重载不能改变语法结构。

例:如果表达式++i*k中的“++”和“*”都是重载的友元运算符,则采⽤运算符函数调⽤格式,该表达式还可表⽰为( B )。

A :operator*(i.operator++(),k)B :operator*(operator++(i),k)C :i. operator++().operator*(k)D :k.operator*(operator++(i))例:在下列成对的表达式中,运算符“+”的意义不相同的⼀对是( C )。

A :5.0+2.0 和 5.0+2 B : 5.0+2.0和 5+2.0C :5.0+2.0 和 5+2 D : 5+2.0 和 5.0+2解:A 中是double + double, 后者虽然是double + int, 但是系统会将2转换为double类型的2.0,所以还是double + double B 同理C左边是double+double右边是int +intD都是double + double所以应该选C例:下列关于运算符重载的叙述中,正确的是A.通过运算符重载,可以定义新的运算符B.有的运算符只能作为成员函数重载C.若重载运算符+,则相应的运算符函数名是+D.重载⼀个⼆元运算符时,必须声明两个形参解:[解析] 运算符重载只能重载现有的运算符,不能创建新的运算符。

c语言函数重载

c语言函数重载

c语言函数重载
c语言函数重载指的是同一个函数可以根据传入参数的不同而有不同的行为。

它通过编译器在编译时,根据参数的类型、个数及顺序来决定调用哪一个函数。

它可以使得同一个函数名称下可以有多个函数实现相同的功能,但是它们的参数列表不同。

c语言函数重载是c语言中实现函数多态性的一种方式,它能够帮助我们实现函数调用的简化,减少代码量,增强代码可读性和可维护性,提高程序的可维护性。

一般来说,c语言函数重载的实现方法有两种,一种是使用预处理器技术,另一种是使用宏技术。

前者使用预处理器技术将多个函数名称重新定义为一个函数名称,然后在函数体内部根据不同的参数类型来实现不同的操作。

而后者则是通过定义宏,然后通过宏中的if/else语句,根据参数的不同来调用不同的函数体。

预处理器技术和宏技术都可以实现函数重载,但是它们的机制不同,因此它们的实现方式也不同。

如果使用预处理器技术,只要将多个函数名称重新定义为一个函数名称,然后在函数体内部根据不同的参数类型来实现不同的操作就可以了。

而如果使用宏技术,则需要先定义一个
宏,然后在宏中定义一个if/else语句,根据参数的不同来调用不同的函数体。

此外,c语言函数重载还可以帮助我们实现函数的重命名,例如将一个函数名称重新定义为另一个函数名称,这样就可以把原来的函数名称彻底抹去,从而避免函数调用出现调用错误的情况,从而更好地保证代码的可维护性。

总而言之,c语言函数重载是c语言中实现函数多态性的一种方式,能够帮助我们实现函数调用的简化,减少代码量,增强代码可读性和可维护性,提高程序的可维护性,并且还可以实现函数的重命名,从而更好地保证代码的可维护性。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘写在前面:函数重载的重要性不言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C ++中函数重载的实现,但我想其它语言也是类似的)?这个可以分解为下面两个问题∙1、声明/定义重载函数时,是如何解决命名冲突的?(抛开函数重载不谈,using就是一种解决命名冲突的方法,解决命名冲突还有很多其它的方法,这里就不论述了)∙2、当我们调用一个重载的函数时,又是如何去解析的?(即怎么知道调用的是哪个函数呢)这两个问题是任何支持函数重载的语言都必须要解决的问题!带着这两个问题,我们开始本文的探讨。

本文的主要内容如下:∙1、例子引入(现象)o什么是函数重载(what)?o为什么需要函数重载(why)?∙2、编译器如何解决命名冲突的?o函数重载为什么不考虑返回值类型∙3、重载函数的调用匹配o模凌两可的情况∙4、编译器是如何解析重载函数调用的?o根据函数名确定候选函数集o确定可用函数o确定最佳匹配函数∙5、总结1、例子引入(现象)1.1、什么是函数重载(what)?函数重载是指在同一作用域内,可以有一组具有相同函数名,不同参数列表的函数,这组函数被称为重载函数。

重载函数通常用来命名一组功能相似的函数,这样做减少了函数名的数量,避免了名字空间的污染,对于程序的可读性有很大的好处。

When two or more different declarations are specified for a single name in the same scope, that name is said to overloaded. By extension, two declaration s in the same scope that declare the same name but with different types are called overloaded declarations. Only function declarations can be overloaded; o bject and type declarations cannot be overloaded. ——摘自《ANSI C++ Standard. P290》在线代理|网页代理|代理网页|在线代理|网页代理|代理网页| 看下面的一个例子,来体会一下:实现一个打印函数,既可以打印int 型、也可以打印字符串型。

在C++中,我们可以这样做:1.#include<iostream> 2.using namespace std; 3.4.void print(int i) 5.{ 6.cout<<"print a integer :"<<i<<endl; 7.} 8.9.void print(string str) 10.{ 11.cout<<"print a string :"<<str<<endl; 12.} 13.14.int main() 15.{ 16.print(12); 17.print("hello world!"); 18.return 0; 19. }通过上面代码的实现,可以根据具体的print()的参数去调用print(int)还是print(string)。

上面print(12)会去调用print(int),print("hello world")会去调用print(string),如下面的结果:(先用g++ test.c 编译,然后执行)1.2、为什么需要函数重载(why )?∙ 试想如果没有函数重载机制,如在C 中,你必须要这样去做:为这个print 函数取不同的名字,如print_int 、print_string 。

这里还只是两个的情况,如果是很多个的话,就需要为实现同一个功能的函数取很多个名字,如加入打印long 型、char*、各种类型的数组等等。

这样做很不友好!∙类的构造函数跟类名相同,也就是说:构造函数都同名。

如果没有函数重载机制,要想实例化不同的对象,那是相当的麻烦! ∙ 操作符重载,本质上就是函数重载,它大大丰富了已有操作符的含义,方便使用,如+可用于连接字符串等!通过上面的介绍我们对函数重载,应该唤醒了我们对函数重载的大概记忆。

下面我们就来分析,C++是如何实现函数重载机制的。

2、编译器如何解决命名冲突的?为了了解编译器是如何处理这些重载函数的,我们反编译下上面我们生成的执行文件,看下汇编代码(全文都是在Linux下面做的实验,Windows类似,你也可以参考《一道简单的题目引发的思考》一文,那里既用到Linux下面的反汇编和Windows下面的反汇编,并注明了Linux 和Windows汇编语言的区别)。

我们执行命令objdump -d a.out >log.txt反汇编并将结果重定向到log.txt文件中,然后分析log.txt文件。

发现函数void print(int i) 编译之后为:(注意它的函数签名变为——_Z5printi)发现函数void print(string str) 编译之后为:(注意它的函数签名变为——_Z5printSs)在线代理|网页代理|代理网页|我们可以发现编译之后,重载函数的名字变了不再都是print!这样不存在命名冲突的问题了,但又有新的问题了——变名机制是怎样的,即如何将一个重载函数的签名映射到一个新的标识?我的第一反应是:函数名+参数列表,因为函数重载取决于参数的类型、个数,而跟返回类型无关。

但看下面的映射关系:void print(int i) --&gt; _Z5printivoid print(string str) --&gt; _Z5printSs进一步猜想,前面的Z5表示返回值类型,print函数名,i表示整型int,Ss表示字符串strin g,即映射为返回类型+函数名+参数列表。

最后在main函数中就是通过_Z5printi、_Z5pr intSs来调用对应的函数的:80489bc: e8 73 ff ff ff call 8048934 <_Z5printi>……………80489f0: e8 7a ff ff ff call 804896f <_Z5printSs>我们再写几个重载函数来验证一下猜想,如:void print(long l) --&gt; _Z5printlvoid print(char str) --&gt; _Z5printc可以发现大概是int-&gt;i,long-&gt;l,char-&gt;c,string-&gt;Ss….基本上都是用首字母代表,现在我们来现在一个函数的返回值类型是否真的对函数变名有影响,如:1.#include<iostream>在线代理|网页代理|代理网页|ing namespace std;3.4.int max(int a,int b)5.{6.return a>=b?a:b;7.}8.9.double max(double a,double b)10.{11.return a>=b?a:b;12.}13.int main()14.{15. cout<<"max int is: "<<max(1,3)<<endl;16. cout<<"max double is: "<<max(1.2,1.3)<<endl;17.return 0;18.}int max(int a,int b) 映射为_Z3maxii、double max(double a,double b) 映射为_Z3 maxdd,这证实了我的猜想,Z后面的数字代码各种返回类型。

更加详细的对应关系,如那个数字对应那个返回类型,哪个字符代表哪重参数类型,就不去具体研究了,因为这个东西跟编译器有关,上面的研究都是基于g++编译器,如果用的是vs编译器的话,对应关系跟这个肯定不一样。

但是规则是一样的:“返回类型+函数名+参数列表”。

既然返回类型也考虑到映射机制中,这样不同的返回类型映射之后的函数名肯定不一样了,但为什么不将函数返回类型考虑到函数重载中呢?——这是为了保持解析操作符或函数调用时,独立于上下文(不依赖于上下文),看下面的例子1.float sqrt(float);2.double sqrt(double);3.4.void f(double da, float fla)5.{6.float fl=sqrt(da);//调用sqrt(double)7.double d=sqrt(da);//调用sqrt(double)8.9. fl=sqrt(fla);//调用sqrt(float)10. d=sqrt(fla);//调用sqrt(float)11.}如果返回类型考虑到函数重载中,这样将不可能再独立于上下文决定调用哪个函数。

在线代理|网页代理|代理网页|至此似乎已经完全分析清楚了,但我们还漏了函数重载的重要限定——作用域。

上面我们介绍的函数重载都是全局函数,下面我们来看一下一个类中的函数重载,用类的对象调用print函数,并根据实参调用不同的函数:1.#include<iostream>ing namespace std;3.4.class test{5.public:6.void print(int i)7. {8. cout<<"int"<<endl;9. }10.void print(char c)11. {12. cout<<"char"<<endl;13. }14.};15.int main()16.{17. test t;18. t.print(1);19. t.print('a');20.return 0;21.}我们现在再来看一下这时print函数映射之后的函数名:void print(int i) --> _ZN4test5printEivoid print(char c) --&gt; _ZN4test5printEc注意前面的N4test,我们可以很容易猜到应该表示作用域,N4可能为命名空间、test类名等等。

相关文档
最新文档