精华内容
下载资源
问答
  • 深入理解C++函数重载const

    千次阅读 2017-08-17 22:12:26
    书上和网上在很多地方都对const重载做了一些解释,但感觉都不是很详细。还有很多同学在不同的地方发问关于const 重载的问题,这里我又重新看了一下,做了一个简单的分析也可能有不对的地方,欢迎讨论。 所谓重载...

    书上和网上在很多地方都对const 的重载做了一些解释,但感觉都不是很详细。还有很多同学在不同的地方发问关于const 重载的问题,这里我又重新看了一下,做了一个简单的分析也可能有不对的地方,欢迎讨论。
    所谓重载,是指允许存在多个同名函数,而这些函数的参数表不同,即函数名相同但函数的签名不同。重载并不是面向对象编程的特有属性,这是因为重载是在编译阶段实现的,编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(这一点稍后有例子)。了

     

     Const 参数重载解析:

     

    关于const 重载几乎在所有c++的书中者提到过但大部分只是一句话,例如在《C++ primer》一书中这样描述:“可基于函数的引用形参是指向 const 对象还是指向非 const 对象,实现函数重载。将引用形参定义为 const 来重载函数是合法的,因为编译器可以根据实参是否为 const 确定调用哪一个函数。”
    但是这一段描述并没有给出引用、指针和值传递前加const的实质区别是什么。在用非const的指针,引用和值均可转化为const的。这一点没有太多可说明的东东。

    对于函数值传递的情况,因为参数传递是通过复制实参创建一个临时变量传递进函数的,函数内只能改变临时变量,但无法改变实参。则这个时候无论加不加const对实参不会产生任何影响。但是在引用或指针传递函数调用中,因为传进去的是一个引用或指针,这样函数内部可以改变引用或指针所指向的变量,这时const 才是实实在在地保护了实参所指向的变量。因为在编译阶段编译器对调用函数的选择是根据实参进行的,所以,只有引用传递和指针传递可以用是否加const来重载。

    下面给出一个例子可能就更明白了:


    输出为:


    通过查看汇编可以知道:

    int foo(int *test);和int foo(const int *test);分别被编译器生成名为:_ZN1A3fooEPKi和_ZN1A3fooEPi(这两个名字会因为编译器的不同而不同,名字只是一个区分的符号而已不用深究,只用知道重载的函数经过编译器的处理函数名字已经发生了变化。所以对于后面的汇编和链接工作就不存在重载的问题了。)这里也同时说明对重载来说在编译阶段已经完成。

    对于a.foo(&b);因为变量b有const修饰所以就调用了int foo(const int *test);对于a.foo(&c);调用int foo(int *test);因为这个是精确匹配的。但是如果没有定义int foo(const int *test);则在代码24行会出现编译错误。反过来如果没有定义函数:int foo(int *test);如下:


    则输出结果为:


    原因c++ primer上讲的很清楚:“We can use a nonconst object to initializer either a const or nonconst reference. However, initializing a const reference to a nonconst object requires a conversion, whereas initializing a nonconst parameter is an exact match.”


    const 成员函数重载的解析

     

    const 成员函数重载的解析和const参数重载解析的原理可以说是一样的。之所以这样说是因为const成员函数的解析可被看做是对函数this参数用const来修饰的过程。例如下面代码:


    总结:

    1.const重载主要是通过能否对传入的参数进行修改为判断的。

    2.const参数重载和const函数重载机制都是一样的,因为对于const 函数重载可看做是对隐含的指针this的参数重载。

    3.重载是在编译阶段已经完成,对于汇编和链接来说透明的。


    展开全文
  • 函数重载const形参的函数重载

    千次阅读 2014-09-04 22:09:34
    1、函数重载和重复声明的区别 如果两个函数声明的返回类型和形参表完全匹配,则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同,但返回类型不同,则第二个声明是错误的: Record ...

    C++primer中文版:

    重载函数:出现在相同作用域中的两个函数,如果具有相同的名字而形参表不同。切记main 函数不能重载

    1、函数重载和重复声明的区别

    如果两个函数声明的返回类型和形参表完全匹配,则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同,但返回类型不同,则第二个声明是错误的:
    Record lookup(const Account&);
    bool lookup(const Account&); // error: only return type is different
    函数不能仅仅基于不同的返回类型而实现重载。
        值得注意的是,形参与 const 形参的等价性仅适用于非引用形参。有 const 引用形参的函数与有非 const 引用形参的函数是不同的。类似地,如果函数带有指向 const 类型的指针形参,则与带有指向相同类型的非 const 对象的指针形参的函数不相同。

    2、函数匹配与实参转换

             函数重载确定,即函数匹配是将函数调用与重载函数集合中的一个函数相关联的过程。通过自动提取函数调用中实际使用的实参与重载集合中各个函数提供的形参做比较,编译器实现该调用与函数的匹配。匹配结果有三种可能:
    1.编译器找到与实参最佳匹配的函数,并生成调用该函数的代码。
    2.找不到形参与函数调用的实参匹配的函数,在这种情况下,编译器将给出编译错误信息。
    3.存在多个与实参匹配的函数,但没有一个是明显的最佳选择。这种情况也是,该调用具有二义性。
        大多数情况下,编译器都可以直接明确地判断一个实际的调用是否合法,如果合法,则应该调用哪一个函数。重载集合中的函数通常有不同个数的参数或无关联的参数类型。当多个函数的形参具有可通过隐式转换关联起来的类型,则函数匹配将相当灵活。在这种情况下,需要程序员充分地掌握函数匹配的过程。

    3、重载确定的三个步骤

    考虑下面的这组函数和函数调用:
    void f();
    void f(int);
    void f(int, int);
    void f(double, double = 3.14);
    f(5.6); // calls void f(double, double)

    3.1 候选函数

    函数重载确定的第一步是确定该调用所考虑的重载函数集合,该集合中的函数称为候选函数。候选函数是与被调函数同名的函数,并且在调用点上,它的声明可见。在这个例子中,有四个名为 f 的候选函数。

    3.2 选择可行函数

        第二步是从候选函数中选择一个或多个函数,它们能够用该调用中指定的实参来调用。因此,选出来的函数称为可行函数。可行函数必须满足两个条件:第一,函数的形参个数与该调用的实参个数相同;第二,每一个实参的类型必须与对应形参的类型匹配,或者可被隐式转换为对应的形参类型。
        对于函数调用 f(5.6),可首先排除两个实参个数不匹配的候选函数。没有形参的 f 函数和有两个 int 型形参的 f 函数对于这个函数调用来说都不可行。例中的调用只有一个实参,而这些函数分别带有零个和两个形参。
    另一方面,有两个 double 型参数的 f 函数可能是可行的。调用带有默认实参的函数时可忽略这个实参。编译器自动将默认实参的值提供给被忽略的实参。因此,某个调用拥有的实参可能比显式给出的多。
        根据实参个数选出潜在的可行函数后,必须检查实参的类型是否与对应的形参类型匹配。与任意函数调用一样,实参必须与它的形参匹配,它们的类型要么精确匹配,要么实参类型能够转换为形参类型。在这个例子中,余下的两个函数都是是可行的。
    •f(int) 是一个可行函数,因为通过隐式转换可将函数调用中的 double型实参转换为该函数唯一的 int 型形参。
    •f(double, double) 也是一个可行函数,因为该函数为其第二个形参提供了默认实参,而且第一个形参是 double 类型,与实参类型精确匹配。
        如果没有找到可行函数,则该调用错误。

    3.3 寻找最佳匹配(如果有的话)

        函数重载确定的第三步是确定与函数调用中使用的实际参数匹配最佳的可行函数。这个过程考虑函数调用中的每一个实参,选择对应形参与之最匹配的一个或多个可行函数。这里所谓“最佳”的细节将在下一节中解释,其原则是实参类型与形参类型越接近则匹配越佳。因此,实参类型与形参类型之间的精确类型匹配比需要转换的匹配好。
        在上述例子中,只需考虑一个 double 类型的显式实参。如果调用 f(int),实参需从 double 型转换为 int 型。而另一个可行函数 f(double, double) 则与该实参精确匹配。由于精确匹配优于需要类型转换的匹配,因此编译器将会把函数调用 f(5.6) 解释为对带有两个 double 形参的 f 函数的调用。

    4、含有多个形参的重载确定

        如果函数调用使用了两个或两个以上的显式实参,则函数匹配会更加复杂。假设有两样的名为 f 的函数,分析下面的函数调用:
    f(42, 2.56);
        可行函数将以同样的方式选出。编译器将选出形参个数和类型都与实参匹配的函数。在本例中,可行函数是 f(int, int) 和 f(double, double)。接下来,编译器通过依次检查每一个实参来决定哪个或哪些函数匹配最佳。如果有且仅有一个函数满足下列条件,则匹配成功:
    1.其每个实参的匹配都不劣于其他可行函数需要的匹配。
    2.至少有一个实参的匹配优于其他可行函数提供的匹配。
        如果在检查了所有实参后,仍找不到唯一最佳匹配函数,则该调用错误。编译器将提示该调用具有二义性。
        在本例子的调用中,首先分析第一个实参,发现函数 f(int, int) 匹配精确。如果使之与第二个函数匹配,就必须将 int 型实参 42 转换为 double 型的值。通过内置转换的匹配“劣于”精确匹配。所以,如果只考虑这个形参,带有两个 int 型形参的函数比带有两个 double 型形参的函数匹配更佳。
        但是,当分析第二个实参时,有两个 double 型形参的函数为实参 2.56 提供了精确匹配。而调用两个 int 型形参的 f 函数版本则需要把 2.56 从 double 型转换为 int 型。所以只考虑第二个形参的话,函数 f(double, double) 匹配更佳。
        如果在检查了所有实参后,仍找不到唯一最佳匹配函数,则该调用错误。编译器将提示该调用具有二义性。
        在本例子的调用中,首先分析第一个实参,发现函数 f(int, int) 匹配精确。如果使之与第二个函数匹配,就必须将 int 型实参 42 转换为 double 型的值。通过内置转换的匹配“劣于”精确匹配。所以,如果只考虑这个形参,带有两个int 型形参的函数比带有两个 double 型形参的函数匹配更佳。
        但是,当分析第二个实参时,有两个 double 型形参的函数为实参 2.56 提供了精确匹配。而调用两个 int 型形参的 f 函数版本则需要把 2.56 从 double 型转换为 int 型。所以只考虑第二个形参的话,函数 f(double, double) 匹配更佳。
        因此,这个调用有二义性:每个可行函数都对函数调用的一个实参实现更好的匹配。编译器将产生错误。解决这样的二义性,可通过显式的强制类型转换强制函数匹配:
    f(static_cast<double>(42), 2.56); // calls f(double, double)
    f(42, static_cast<int>(2.56)); // calls f(int, int)
        在实际应用中,调用重载函数时应尽量避免对实参做强制类型转换:需要使用强制类型转换意味着所设计的形
    参集合不合理。

    5、实参类型转换

        为了确定最佳匹配,编译器将实参类型到相应形参类型转换划分等级。转换等级以降序排列如下:
    1.精确匹配。实参与形参类型相同。
    2.通过类型提升实现的匹配。
    3.通过标准转换实现的匹配。
    4.通过类类型转换实现的匹配。
        内置类型的提升和转换可能会使函数匹配产生意想不到的结果。但幸运的是,设计良好的系统很少会包含与下面例子类似的形参类型如此接近的函数。
    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    (转载)含有const形参函数的重载:

    record lookup( phone);

    record lookup(const phone);

    这两个属于函数重载吗?

    这个还需要从实参与形参之间的关系中去寻找答案,这对的区别仅仅在于是否将形参定义为const,这种差异并不影响传递到函数的对象,因此第二个函数声明被视为第一个的重复声明。

    起因:实参传递方式。复制实参的副本给形参时并不考虑形参是否为const,因为函数操纵的只是副本。函数无法修改实参。因此,既可将const对象传递给const形参,也可传递给非const形参,这两种形参并无本质区别。

    例如:

    record lookup(15001805405);//这里就假设传递个本人的手机号码吧

    此时该调用上面哪个函数呢?很明显两个都可以,形参跟实参都有属于各自的爹妈,各自的空间,互不干涉。

    然而这个时候编译器就会傻眼,二义性问题,编译器就成了sb了,因此结论:这组函数不属于函数重载。

    ps:形参与const形参的等价性仅仅适用于非引用形参。有const引用形参的函数与有非const引用形参的函数是不同的。近似的,如果函数带有指向const类型的指针形参,则与带有指向相同类型的非const对象的指针形参的函数不形同。

    record lookup(const phone&);

    record lookup(phone&);

    那这两个呢?属于函数重载吗?

    答案是属于。肯定属于。

    例如:

    const phone a=15001805405;//贡献第二次

    record lookup(a);这个该调用那个呢?

    很明显大家都晓得,上面那个。理由就不需要唠叨了吧。

    有人会问这个问题:

    phone a=15001805405;

    那这个该调用那个呢?

    下面那个?上面那个?

    结论:这种情况优先匹配非const那个,如果没有那也可以匹配const这个。

    有依据没? 有的,经试验测试得出的结论:

    试验如下:

    #include<iostream>
    using namespace std;
    int sb(const int& b)
    {
    cout<<"今天晚上我让她反感了!这是我的错!"<<endl;
    return b;
    }
    int sb(int &b)
    {
    cout<<"不过我认为第一次嘛,可以原谅吧,做人好难,也好累!"<<endl;
    return b;
    }
    int main()
    {
    int a=2;
    cout<<sb(a)<<endl;

    cout<<"有些事想明白了就是幸福,想不明白就是痛苦!"<<endl;
    return EXIT_SUCCESS;
    }

    -------------------------------------------------------------------------------------------------------------------------------------
    《C++ primer》中提到“仅当形参是引用或指针的时候,形参是否为const才对重载有影响。”
     
    int add(int a, int b);
    int add(const int a, const int b);
    我想通过定义这两个函数来实现实参是否为const的重载,可事与愿违,这里的第二个函数并没有对第一个进行overloading,而是redefinition。因为,在此的两个函数的形参并不会直接关联到实参,在调用这两个函数的时候,形参都只是实参的一个副本,不管add函数内部对形参做什么处理,都不会影响到实参,也就是说——第二个函数形参中的const没有任何的用处,只是多此一举罢了。所以在此的第二个定义只是对第一个的重定义罢了。

    int add(int &a, int &b);
    int add(const int &a, const int &b);
    这次定义的两个函数与上面不同的地方就是形参使用了引用。这个时候编译器就完全可以根据实参是否为const确定调用哪一个函数了。调用如下:
    //非const变量x, y
    int x = 1;
    int y = 2;

    add(x, y); //call add(int &a, int &b)

    //const变量x, y
    const int x = 1;
    const int y = 2;

    add(x, y); //call add(const int &a, const int &b)
    上述第一种情况:实参为非const对象的时候,其实两个函数都可以被调用,都与之匹配,因为非const对象不但可以初始化非const引用,也可以初始化const引用。但由于非const对象初始化const引用的时候涉及到类型转换,所以此时带非const引用形参的函数为最佳匹配。
    上述第二种情况:实参为const对象的时候,就不能将此对象传递给带非const引用的形参的函数了,因为const对象只能用来初始化const引用。

    int add(int *a, int *b);
    int add(const int *a, const int *b);

    //非const对象
    int x = 1;
    int y = 2;
    //cosnt对象
    const int r = 1;
    const int s = 2;

    add(&x, &y); //call add(int *a, int *b);
    add(&r, &s); //call add(cosnt int *a, cosnt int *b);

    展开全文
  • const 参数重载与const 成员函数重载

    千次阅读 2017-10-18 20:59:01
    const 参数重载《C++ primer》一书中这样描述:“可基于函数的引用形参是指向 const 对象还是指向非 const 对象,实现函数重载。将引用形参定义为 const 来重载函数是合法的,因为编译器可以根据实参是否为 const ...

    const 参数重载

    《C++ primer》一书中这样描述:“可基于函数的引用形参是指向 const 对象还是指向非 const 对象,实现函数重载。将引用形参定义为 const 来重载函数是合法的,因为编译器可以根据实参是否为 const 确定调用哪一个函数。”
    

    但是这一段描述并没有给出引用、指针和值传递前加const的实质区别是什么。在用非const的指针,引用和值均可转化为const的。
    对于函数值传递的情况,因为参数传递是通过复制实参创建一个临时变量传递进函数的,函数内只能改变临时变量,但无法改变实参。则这个时候无论加不加const对实参不会产生任何影响。但是在引用或指针传递函数调用中,因为传进去的是一个引用或指针,这样函数内部可以改变引用或指针所指向的变量,这时const 才是实实在在地保护了实参所指向的变量。因为在编译阶段编译器对调用函数的选择是根据实参进行的,所以,只有引用传递和指针传递可以用是否加const来重载

    const成员函数重载

    const成员函数的解析可被看做是对函数this参数用const来修饰的过程

    class A{  
    public:  
        A();  
        int foo(int *test); //可看做:int foo(A *this,int *test);  
        int foo(int *test) const;//可看做:int foo(const A *this,int *test);  
    };  
    A::A(){  
    }  
    int A::foo(int *test){  
        std::cout << *test << "foo" <<std::endl;  
        return 1;  
    }  
    int A::foo(int *test) const {  
        std::cout << *test << "foo const" <<std::endl;  
        return 1;  
    }  
    int main()  
    {  
        int b = 5;  
        const A a;  
        a.foo(&b);  //调用的是int foo(int *test) const;
        return 1;  
    }  

    总结:

    1. const重载主要是通过能否对传入的参数进行修改为判断的

    2. const参数重载和const函数重载机制都是一样的,因为对于const 函数重载可看做是对隐含的指针this的参数重载

    3. 重载是在编译阶段已经完成,对于汇编和链接来说透明的。

    展开全文
  • 函数重载const

    千次阅读 2014-10-13 20:36:09
    我们知道,如果函数名相同,在相同的作用域内,其参数类型、参数个数,参数顺序不同等能构成函数重载。有趣的是如果同时在类中,对于函数名相同的const函数和非const函数能够构成重载,同时它们被调用的时机为:如果...

    我们知道,如果函数名相同,在相同的作用域内,其参数类型、参数个数,参数顺序不同等能构成函数重载。有趣的是如果同时在类中,对于函数名相同的const函数和非const函数能够构成重载,同时它们被调用的时机为:如果定义的对象是常对象,则调用的是const成员函数,如果定义的对象是非常对象,则调用重载的非const成员函数。例如:
    #include <iostream>
    using namespace std;
    class A
    {
    public:
           A( int x )
           {
                  m = x;
           }
           
           int func( void )
           {
                cout << "non-const" << endl;
                m = 1700; //本函数体没有声明为const,允许修改成员数据 
                return m;
           }
           
           //函数体限制为const, 
           int func( void )const
           {
                 cout << "const" << endl;             
                 return m;
           }
    private:
            int m;
    };

    int main( void )
    {
        A b( 2002 );
        b.func( ); //调用 非const版本的func() 
        
        const A c( 2002 );
        c.func( ); //调用 const版本的func() 

       system( "PAUSE" );
       return 0;

    }

    另外,应该把不修改相应实参的形参定义为const引用,否则将限制该函数的使用,下面代码将产生编译错误:
     string::size_type find_char(string &s, char c)
     {
      while(i!=s.size()&&s[i]!=c) ++i;
      return i;
     }
     int main()
     {
      find_char("Hello World", 'o') //error
      return 0;
     }

            错误的原因:虽然字符串字面值传递给函数可以产生局部对象,但是这里形参被声明为引用,必须引用一个已存在的对象,所以上述代码才会导致编译错误。
            仅当形参是引用或指针时,形参是否为const才有重载现象。
    class Account 
    {  }; 
    void lookup(Account &)
    { }
    void lookup(const Account &)
    { }       

    void lookup3(Account *)
    { }
    void lookup3( Account const*)
    { }
    void lookup4(Account *) //错误,不能重载
    { }
    void lookup4( Account *const)//错误,不能重载
    { } 

    const Account a(0);
    Account b;
    lookup(a);  //call lookup(const Account &)
    lookup(b);  //call lookup(Account &)

    注意:不能基于指针本身是否为const来实现函数的重载。例如,
     f(int *);
     f(int *const);
     以上两个函数无法构成重载。

    通常地,不同的重载函数不能具有相同数目的参数和参数类型。函数的返回值类型,虽然属于成员函数的signature的组成部分,但仅仅返回值类型不同,是不能构成函数重载的,因为这会造成redefinition的错误。

     

    但有一个例外,就是使用const关键字进行函数重载,是成员函数成为const函数。见下面的代码:

    // Overloading Based on const

    #include <iostream>

    #include <string>

    using namespace std;

     

    class AClass

    {

    public:

             AClass():greetingwords("Hello, world!")

             {

             }

     

             string greeting()                                 // (1)

             {

                       return greetingwords + " - from nonconst version.";

             }

     

             //const string greeting()                       // (2)

             //{

             //       return greetingwords + " - from right const version.";

             //}

     

             //string greeting() const                       // (3)

             //{

             //       return greetingwords + " - from right const version.";

             //}

     

             const string greeting() const             // (4)

             {

                       return greetingwords + " - from const - const version.";

             }

     

    private:

             const string greetingwords;

    };

     

    int main(void)

    {

             AClass a_class;

             const AClass b_class;

             cout << a_class.greeting() << endl;

             cout << b_class.greeting() << endl;

     

             return 0;

    }

     

    说明:

    a.       (1)(4)中的greeting的参数数目和类型都是完全一致的(两个函数都没有参数),按照通常的说法,这会出现编译错误,但事实上,上面的程序可以正常运行。因此,(1)(4)中的两个greeting函数,并无redefinition的问题,这是因为(4)中的greeting函数名称后有一个const关键字的缘故;

    b.      同样道理,如果将这个(4)定义的greeting注释掉,使用(3)中的greeting函数的定义,结果也是正确的,因为(3)中的greeting函数名称后也有一个const关键字;

    c.      (3)(4)不能同时出现,否则会出现redefinition的编译错误。因为它们之间的不同仅是返回值类型不同,一个是string,另一个是const string,而仅仅是返回值类型的不同,编译器是无法区分两个重载函数的不同;

    d.      基于上面的道理,(1)(2)也不能同时出现;

    e.      结论。如果两个函数的参数数目和数据类型都是一样的,只要将其中一个改为const成员函数(即,函数名称和参数后又const关键字),则仍然可以构成有效的函数重载;

    f.       输出。上面的代码输出:

    Hello, world! – from nonconst version.

    Hello, world! – from const – const version.

           a_class是一个nonconst对象,因此选择了(1)中的greeting定义;b_class是一个const对象,因此选择了(4)中的greeting定义。


    展开全文
  • 顶层Const和底层Const——函数重载 Const指针的意义 不希望改变指针的指向,这个指针指向的值不希望被改变。 不希望改变这个指针所指向的值。 int a = 4; int b = 5; int *const ptr = &amp;a; ptr = &...
  • 函数重载机制会自动假装忽略掉顶层const而保留底层const。 3.对于函数形参中的引用,尽量使用常量引用。首先,如果使用普通引用,会带给调用者一种误导,即函数可以修改它的实参的值。此外,使用普通引用而非常量...
  • C++函数重载系列第3篇,const关键字详解
  • const函数重载

    2014-09-17 16:22:47
    C++允许类的成员函数基于const重载
  • 书上和网上在很多地方都对const重载做了一些解释,但感觉都不是很详细。还有很多同学在不同的地方发问关于const 重载的问题,这里我又重新看了一下,做了一个简单的分析也可能有不对的地方,欢迎讨论。 所谓重载...
  • 在C++中void func() const 和void func()可以形成重载函数,如果void func() const和void func()写同样的代码实现func功能,这样就造成了代码浪费(重复写代码)。这种问题的解决方式就是利用static_cast达到代码复用...
  • 函数重载 函数重载的定义是:在相同的作用域中,如果函数具有相同名字而仅仅是形参表不同,此时成为函数重载。注意函数重载不能基于不同的返回值类型进行重载。 注意函数重载中的“形参表”不同,是指本质不同...
  • 主要介绍了C++中const用于函数重载的相关资料,需要的朋友可以参考下
  • C++函数重载const特征标

    千次阅读 2013-10-22 22:47:01
    C++中,普通函数重载需要满足一定的条件,如: 1、形参的个数不同 2、形参的类型不同 3、形参的类型和个数都不同 总之,普通函数重载取决于形参的个数和类型,与函数的返回值类型无关。 但是,在类中,函数将区分...
  • c++中 运算符重载 const 函数

    千次阅读 2018-11-10 14:57:10
    本篇文章主要内容是关于运算符重载,然后在最后提了一下 const修饰函数时的状况。后面会补上一个日期类的定义。 文章目录概要赋值运算符的重载= 号的重载i++ 和 ++i 前置与后置++的区别const 修饰函数 赋值运算符的...
  • 函数参数的const重载只能重载引用型的,因为非引用的const和普通的非const参数一样。 成员函数const重载总共有三种方式,有三个地方可以写const,要注意const在不同的地方的意义。 #include #include #include ...
  • T & Container::front(){...} T & Container::front() const {...}
  • 函数重载 函数重载的定义是:在相同的作用域中,如果函数具有相同名字而仅仅是形参表不同,此时成为函数重载。注意函数重载不能基于不同的返回值类型进行重载。 注意函数重载中的“形参表”不同,是指本质不同,...
  • C++ 成员函数 const 重载

    千次阅读 2015-05-18 21:24:08
    众所周知,C++类实现函数重载有两种情况:函数参数的类型不同,参数的个数不同。而与函数的返回值没有什么关系。还有一种类成员函数重载,它并不要求函数的参数类型不同。下面给出例子: #include using namespace...
  • C++ const函数重载的影响

    千次阅读 2019-08-20 21:00:07
    重载,是指允许存在多个同名函数,而这些函数的参数表不同,即函数名相同但函数的签名...一、const 修饰成员函数时的重载 第一种情况: #include<iostream> using namespace std; void fun(const int i...
  • 函数重载const的关系: 1、如果形参是非引用类型的,则下面两个函数是编译报错的(error C2084: 函数“void rldFunction(int)”已有主体) void rldFunction(int paraIn) { cout ; } void rldFunction(const ...
  • 一般来说,对于重载函数来... 但是,另一方面,对于指针和引用来说,可以通过区分形参指向的是常量还是非常量来实现函数重载。此时的const是底层的。 Example: Record lookup(Account&); //函数作用于Account的引用 R
  • 通常地,不同的重载函数不能具有相同数目的参数和参数类型。...但有一个例外,就是使用const关键字进行函数重载,是成员函数成为const函数。见下面的代码: // Overloading Based on const #include 
  • const函数重载, 函数返回值之间的关系 const函数重载: 之前说过函数重载,对于参数来说,const是否能构成一种新的参数类型呢? 例如: Funx(int a); Funx(const int a);这俩是否能构成重载呢? 答案...
  • const 和 非const函数重载

    千次阅读 2015-07-13 20:17:35
    在下面的代码中a1调用const版本,a2调用非...后面加const表示在该函数中不能对类的数据成员进行改变,比如: class A { private: int aa; public: int x() { return aa++; } //这可以 int x() const { return aa++;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,895
精华内容 60,758
关键字:

函数重载const