精华内容
下载资源
问答
  • 我们先看以下三个共同术语来区分: ①要正常f()进行重载(overload)...编译器将会依据实际提供參数来选择最匹配的函数。 ②对虚函数f()进行覆盖(override)是表示,在派生类中定义一个同样名字(f)的函数...

    我们先看以下三个共同的术语来区分:

    ①要正常f()进行重载(overload)是表示,在同样的作用域中定义还有一个同样的名字(f)的函数,而且这个函数与f()有着不同的參数个数和參数类型。当程序调用函数f()时。编译器将会依据实际提供的參数来选择最匹配的函数。

    ②对虚函数f()进行覆盖(override)是表示,在派生类中定义一个同样的名字(f)的函数。而且这个函数的參数个数和參数类型与f()是同样的。

    ③对外层作用域(基类、外部类或者名字空间)中的函数f()进行隐藏(hide)是表示在内层作用域(派生类、嵌套类或者嵌套名字空间)中定义还有一个同样名字(f)的函数,这将隐藏外层作用域中同样名字的函数。

    以下看一个样例:

    class Base

    {

    public:

       virtual void f(int);

       virtual void f(double);

       virtual void g(int i = 10);

    };

    void Base::f(int)

    {

       cout << "Base::f(int)" << endl;

    }

    void Base::f(double)

    {

       cout << "Base::f(double)" << endl;

    }

    void Base::g(int i)

    {

       cout << i << endl;

    }

    class Derived:public Base

    {

    public:

       void f(complex<double>);

       void g(int i = 20);

    };

    void Derived::f(complex<double> a)

    {

       cout << "Derived::f(complex)" << endl;

    }

    void Derived::g(int i)

    {

       cout << "Derived::g()" << i << endl;

    }

    int main()

    {

       Base b;

       Derived d;

       Base* pb = new Derived;

       b.f(1.0);

       d.f(1.0);

       pb->f(1.0);

       b.g();

       d.g();

       pb->g();

       delete pb;

       return 0;

    }

    ①“delete pb;”是不安全的

    我们通常应该将基类的析构函数定义为虚函数。

    在上面的代码中,我们是通过指向基类的指针来删除派生类的对象,而在基类中并未定义虚析构函数,那么这就会产生问题,上面代码将调用错误的析构函数。

    ②Derived::f不是重载函数

    在Derived类中并非对Base::f进行重载,而是隐藏了这个函数。

    这个差别是非常重要的。由于它意味着在Derived的作用域中,Base::f(int)和Base::f(double)将是不可见的。假设要将Base::f这个名字引入到Derived的作用域中。正确地方法是使用using声明语句------“using Base::f"。

    ③我们永远都不要去改变所覆盖的基类函数中的默认參数值

    函数Derived::g覆盖了Base::g,但却改变了默认參数值void g(int i = 20);

    以下分析上面的程序的输出结果:

    b.f(1.0);调用Base::f(double),这与程序猿所期望的是一致的。

    d.f(1.0);将调用Derived::f(complex<double>).由于Base::f(int)和Base::f(double)被Derived::f(complex<double>)隐藏了。

    我们可能希望这行代码会去调用Base::f(double),但在这样的情况下是不会的,并且编译器甚至不会报错。由于幸运的是,complex<double>可以提供从double来的隐式转换,因此编译器会将这个调用解释为Derived::f(complex<double>(1.0)).

    pb->f(1.0);尽管指针Base  * pb指向的是一个Derived对象,但上面这行代码调用的却是Base::f(double),这是由于重载解析仅仅是作用于静态类型(这里是Base),而不是动态类型(这里是Derived)。同理,函数调用”pb->f(complex<double>(1.0))“将无法通过编译,这是由于在Base的接口中没有符合要求的函数。

    b.g();将输出”10“,调用了Base::g(int).

    d.g();将输出”Derived::g()20"。由于这仅仅是调用了Derived::g(int),而这个函数的默认參数值是20.

    pb->g();这将输出“Derived::g()10"。我们要记住的是,,在相同的函数重载。默认参数是静态类型的对象从(这是Base)。由此得到的默认值它是10.然而。因为该功能是一个虚函数,因此,该函数的实际动态类型由对象称为(这是Derived)决定。






    本文转自mfrbuaa博客园博客,原文链接:http://www.cnblogs.com/mfrbuaa/p/5028693.html,如需转载请自行联系原作者


    展开全文
  • C++函数重载可以这样简单理解。 ...故在这两个函数调用时,会依据起参数类型选择性调用第一还是第二个函数。 这就是C++函数重载的一种情况。 另一种情况是函数名称相同,但是参数数目不同。 ...

    C++函数重载

    C++函数重载可以这样简单理解。

    作者的话:

    1、本文章供大家参考学习,欢迎朋友们留言交流,也希望有朋友有其他见解。
    2、文章写的很冲忙,若有错误,还请赐教。
    3、你的点赞是对我的最大鼓舞。>^ _ ^<(疯狂暗示)。

    情况一

    下面为大家展示例题:

    #include<iostream>
    
    void print( int *pstart , int *pend );				//声明函数
    void print( char *pstart , char *pend );			//声明函数
    
    int main()
    {
    	const unsigned short X = 5;						//相当于宏定义。(可以这么理解)
    	int IntArrar[X] = {1,2,3,4,5};					//定义一个int型数组。
    	char CharArrar[X] = {'a','y','r','m','j'};		//定义一个char型数组。
    
    	int *pInt = IntArrar;							//定义一个int型指针变量
    	char *pChar = CharArrar;						//定义一个char型指针变量
    
    	print( IntArrar , IntArrar + 5 );				//调用函数1
    	print( CharArrar , CharArrar + 5);				//调用函数2
    
    	return 0;
    }
    
    void print( int *pstart , int *pend )
    {
    	while( pstart != pend )							//输出
    	{
    		std::cout << *pstart << " " ;
    		pstart++;
    	}
    	std::cout << std::endl;
    }
    
    void print( char *pstart , char *pend )
    {
    	while( pstart != pend )							//输出
    	{
    		std::cout << *pstart << " " ;
    		pstart++;
    	}
    	std::cout << std::endl;
    }
    

    可见两个函数的名称均为"print" ,并且返回值均为void。
    但是他们的参数类型不同,一个为int整型,一个为char字符型。
    故在这两个函数被调用时,会依据起参数类型选择性调用第一还是第二个函数。
    这就是C++函数重载的一种情况。

    情况二

    另一种情况是函数名称相同,但是参数数目不同。

    下面展示例题:

    #include<iostream>
    
    void calc( double a );							//声明
    void calc( double a , double b );				//声明
    void calc( double a , double b , double c);		//声明
    
    int main()
    {
    	std::cout << "请输入数字(用空格隔开):	" ;
    
    	double a[3];
    	int i = 0;
    	while( std::cin.peek() != '\n' && i < 3 )
    	{
    		if( std::cin.peek() == ' ')				//如果是空格,用std::cin.get()吃掉。
    		{
    			std::cin.get();
    			continue;
    		}
    
    		std::cin >> a[i];						//赋值。
    		i++;
    	}
    
    	switch(i)								//判断参数数目进行调用
    	{
    	case 1:
    		calc( a[0] );
    		break;
    	case 2:
    		calc( a[0] , a[1] );
    		break;
    	case 3:
    		calc( a[0] , a[1] , a[2] );
    		break;
    	}
    
    	return 0;
    }
    
    void calc( double a )						//输入一个数字会输出他的平方。
    {
    	std::cout << a * a << std::endl;
    }
    
    void calc( double a , double b )			//输入两个数字会输出他们的乘积。
    {
    	std::cout << a * b << std::endl;
    }
    
    void calc( double a , double b , double c)	//输入三个数字会输出他们的和。
    {
    	std::cout << a + b + c << std::endl;
    }
    

    很明显这里有三个名称为calc函数。
    但是他们的函数参数数目不同(一个为1个,一个为2个,一个为3个)。
    简单的来说,函数的重载就是函数名相同,但是参数的个数类型不同。

    本文章只在本人的知识范围内,若有更深的见解,欢迎在下方评论区留言哦。

    你的点赞是对我的最大鼓舞。>^ _ ^<(疯狂暗示)(手动滑稽)

    展开全文
  • 选择题 20题共 30分 作用域运算符功能 设置虚基类目的 构造函数特征 析构函数说法 重载函数调用时选择的依据 静态成员特性 友元 派生类描述 运算符在 C++中不能被重载 动态联编描述 纯虚函数和抽象...
  • C++考试复习内容

    2020-09-26 16:48:30
    重载函数调用时选择的依据参数类型 函数名字,参数个数和类型有关,与参数名字无关。 纯虚函数是一种特殊虚函数,它没有具体实现; 含有纯虚函数类叫做抽象类。这种类不能声明对象,只是作为基类为...

    个人不熟知识点

    派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

    int m=20; while (m=0) m=m++;中 while (m=0),m赋值为0,while(0)结束。故一次都未执行。

    重载函数在调用时选择的依据参数的类型 函数的名字,参数的个数和类型有关,与参数的名字无关。

    纯虚函数是一种特殊的虚函数,它没有具体的实现;
    含有纯虚函数的类叫做抽象类。这种类不能声明对象,只是作为基类为派生类服务。

    virtual <类型><函数名>(<参数表>)=0;
    抽象类是指具有纯虚函数的类;
    一个基类中有纯虚函数,该基类的派生类也可能是抽象类;
    抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出;

    一个类中若包含另一个类的对象,这个对象称为子对象或成员对象。叫类的组合。
    在面向对象分析和设计中,通常把对象所进行的操作称为方法或服务

    在面向对象程序设计方法中,对象是系统中用来描述客观事物的一个实体,它由数据和可执行的一组操作共同组成。

    多态:
    1.运行时多态:取子类地址赋给父类指针,此指针再指向子类成员(同名虚函数) virtual void Speak() {cout<<“How does a pet speak ?”<<endl; }

    2.编译时多态:函数重载(只与参数有关,参数的类型和数量。与返回值无关)

    函数重载和运算符重载都属于重载多态。
    基类指针指向派生类对象,在调用派生类函数,此为运行时多态。

    函数指针:

    还有PtaA卷
    友元函数
    New与delete

    									不想扔,所以就把它留在这里了
    
    展开全文
  • 2013出笔试题

    2013-11-06 20:40:55
    选择 1.print()函数是一个类常成员函数,它无返回值,下列表示中正确是。( A )  A) void print()const;...2.系统在调用重载函数时,不能作为确定哪个重载函数调用的依据是:( D ) A) 参数个数

    又到校招时,领导让出题,随便想了几个

    选择

    1.print()函数是一个类的常成员函数,它无返回值,下列表示中正确的是。(  A  ) 
    A) void print()const;     B) const void print();

    C) void constprint();   D)void print(const);

    2.系统在调用重载函数时,不能作为确定哪个重载函数被调用的依据是:(  D  )  
    A) 参数个数    B) 参数类型    
    C) 函数名称    D) 函数的返回值类型 

    填空

    1. #include <stdio.h>和#include "stdio.h"的区别是__前者优先从编译器类库路径中查找,后者优先从当前目录查找__
    2. 下面代码是一个字符串类的一部分
    class String
    {
    ...
    String& string::operator=(const String& rhs)
    {
    ...
    return *this;
    }
    ...

    }

    重载=运算符返回*this的原因是__让String类可以链式赋值如a=b=c="hello"__

    问答

    1.IEEE浮点标准采用V=(-1)^s*M*2^E的形式来表示一个数。C语言单精度浮点数float采用32比特存储,由高位到低位分为3个区域,含义依次为

    最高1位s,表示符号是负数(s=1)还是正数(s=0)

    接下来的8位e,表示指数

    接下来的23位f,表示M

    这样,一个32位浮点数可以类似这样表示se7e6...e0f22f21...f0

    浮点数结果为

    V=(-1)^s * M * E

    其中:

    M= 1.f22f21...f0

    E = 2^((e7e6...e0)- (2^7-1))

    采用这种方式表示的一个浮点数在内存中数据为0xc2f60000,这个浮点数的大小为多少?

     

    答:内存中数据为0xc2f60000的数据对应

    M = 1.1110110 = 1+ 1/2 +1/4 + 1/8 + 1/32 + 1/64 = 1.926875

    E = 2^((10000101)- (2^7-1)) = 2^6 = 64

    s=1表示这个数为负数

    最后结果V= -1 * M * E = -123

     

     

    展开全文
  • C++期末

    2013-07-09 17:58:00
    华侨大学 面向对象程序设计(二) 试卷(A) 系别 计算机、软件工程、网络工程08 考试日期 2009年 06月29日 姓名 学号 成绩 ...(1)关于重载函数调用时匹配依据的说法中,错误是 (1) D 。 A)参数个数 ...
  • c++ 程序设计

    2019-01-20 22:53:37
    10.4 运算符重载函数作为类成员函数和友元函数 10.5 重载双目运算符 10.6 重载单目运算符 10.7 重载流插入运算符和流提取运算符 10.7.1 重载流插入运算符“” 10.7.2 重载流提取运算符“>>” 10.8 不同类型数据间...
  • finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。 16、sleep() 和 wait() 有什么区别? sleep是线程类(Thread)...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    18.2 在 C #代码中调用 C++和 VB 编写组件 .240 18.3 版 本 控 制 .249 18.4 代 码 优 化 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间...
  • C#微软培训资料

    2014-01-22 14:10:17
    18.2 在 C #代码中调用 C++和 VB 编写组件 .240 18.3 版 本 控 制 .249 18.4 代 码 优 化 .252 18.5 小 结 .254 第五部分 附 录 .255 附录 A 关 键 字.255 附录 B 错 误 码.256 附录 C .Net 名字空间...
  • java 面试题 总结

    2009-09-16 08:45:34
    finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。 13、sleep() 和 wait() 有什么区别? sleep是线程类(Thread)的...
  • 关于DFT部分,由于我在DFT算法里面使用了Complex类与COMPLEX结构体(类包含了运算符的重载与一些常用函数),毕竟C语言并没有专用复数运算可以调用。 所以在进行DFT运算会不断调用构造函数与析构函数,...
  • 7.4 重载函数名 133 7.4.1 重载和返回类型 135 7.4.2 重载与作用域 135 7.4.3 手工歧义性解析 135 7.4.4 多参数解析 136 7.5 默认参数 137 7.6 未确定数目参数 138 7.7 指向函数指针 139 7.8 宏 143...
  • C++程序设计语言(特别版)--源代码

    热门讨论 2012-04-23 07:33:51
    7.4 重载函数名 133 7.4.1 重载和返回类型 135 7.4.2 重载与作用域 135 7.4.3 手工歧义性解析 135 7.4.4 多参数解析 136 7.5 默认参数 137 7.6 未确定数目参数 138 7.7 指向函数指针 139 7.8 宏 143...
  • 7.4 重载函数名 133 7.4.1 重载和返回类型 135 7.4.2 重载与作用域 135 7.4.3 手工歧义性解析 135 7.4.4 多参数解析 136 7.5 默认参数 137 7.6 未确定数目参数 138 7.7 指向函数指针 139 7.8 宏 143...
  • 1、严格按照微服务划分来做,微服务相互独立,各微服务数据库也独立,后台需要展示数据调用各微服务接口来获取对应数据, 再进行数据处理后展示出来,这是标准用法,也是最麻烦用法。 2、将业务高度...
  • 5个目标文件,演示Address EJB实现 ,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化上下文,用clientgetHome()函数调用Home接口...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    5个目标文件,演示Address EJB实现,创建一个EJB测试客户端,得到名字上下文,查询jndi名,通过强制转型得到Home接口,getInitialContext()函数返回一个经过初始化上下文,用clientgetHome()函数调用Home接口...
  • 精通正则表达式(中英)

    热门讨论 2011-09-08 13:18:58
    规则1:优先选择最左端匹配结果 148 引擎构造 149 规则2:标准量词是匹配优先 151 表达式主导与文本主导 153 nfa引擎:表达式主导 153 dfa引擎:文本主导 155 第一想法:比较nfa与dfa 156 回溯 157 真实世界中...
  • 精通正则表达式~~~

    2009-05-07 12:36:48
    规则1:优先选择最左端匹配结果... 148 引擎构造... 149 规则2:标准量词是匹配优先... 151 表达式主导与文本主导... 153 NFA引擎:表达式主导... 153 DFA引擎:文本主导... 155 第一想法:比较NFA与...
  • 在文件最后加入Nand Flash初始化函数,该函数在后面Nand Flash操作都要用到。 u-boot运行到第2阶段会进入start_armboot()函数。其中nand_init()函数是对nand flash最 初初始化函数。nand_init()函数在两个...

空空如也

空空如也

1 2
收藏数 24
精华内容 9
关键字:

重载函数调用时的选择依据