重载，const参数，const_cast，const_cast <string &>

Question

我正在阅读C ++ Primer ，发现有些东西很奇怪而且很难理解：

Record lookup(Account&);  //Record and Account are two unrelated class
Record lookup(const Account&);

因此，这两个函数都接受非常量对象（首先匹配非常量参数函数），但是只有第二个函数可以接受常量对象。

在下一节（ const_cast和重载 ）中，我有以下代码：

const string &shorterString(const string &s1, const string &s2){
   return s1.size() < s2.size() ? s1 : s2;
}   

string &shorterString(string &s1, string &s2){
   auto &r = shorterString(const_cast<const string&>(s1),
                           const_cast<const string&>(s2));
   return const_cast<string &>)(r);
}

const_cast<const string&>(s1)是什么意思？

有人告诉我：

引用是对象，只是带有另一个名称。 它既不是指向该对象的指针，也不是该对象的副本。 它是对象。

因此，我传递了一个字符串对象以初始化引用s1 ，因此s1本身是一个字符串对象，那么它如何将string为const string&然后匹配其他函数？

应该如何理解函数调用？

shorterString(const_cast<const string&>(s1),const_cast<const string&>(s2));

是否使用引用来初始化引用？ 但是由于引用是对象本身，所以我使用的是s1所引用的对象initialize及其字符串。 再一次， const_cast<const string&)(s1) ，将string为const string& ？

从我的角度来看，如果您有一个字符串对象，那么您只能匹配非常量引用参数function ，并且没有类似的东西：

string s1 = "abc";
string s2 = "efg";
shorterString(const(s1), const(s2));   //no such top-level const cast

PS：谈到非const和const指针参数时，这是可以理解的。

如果遇到麻烦的问题，我上传了本书中相关段落的屏幕截图：

1. https://imgur.com/tnqrxVY
2. https://imgur.com/hF1MjUH
3. https://imgur.com/Fg2zeEw

Answer 1

有两个重载函数。 一种设计用于常量对象，另一种设计用于非常量对象。

非常量对象的函数实现是基于对常量对象的函数调用而建立的。

如果删除参数的强制转换，则非常量对象的函数将尝试递归调用自身。

为了允许编译器在非常量对象的函数中选择常量对象的函数，必须使用const__cast显式转换参数。

同样，由于常量对象的函数返回常量引用，而非常量对象的函数返回非常量引用，则必须将常量对象的函数的返回引用转换为非常量引用。

因此，首先，您必须将参数传递给常量引用，以调用常量对象的函数，然后必须将函数的返回引用（针对常量对象的对象）再次强制转换为非常量引用。

这是一个演示程序。

#include <iostream>
#include <string>

const std::string & shorterString( const std::string &s1, const std::string &s2 )
{
    std::cout << 
        "const std::string & shorterString( const std::string &, const std::string )"
        " called\n";
    return s2.size() < s1.size() ? s2 : s1;
}   

std::string & shorterString( std::string &s1, std::string &s2 )
{
    std::cout << 
        "std::string & shorterString( std::string &, std::string )"
        " called\n";
   return const_cast<std::string &>( shorterString( const_cast<const std::string&>( s1 ),
                                                    const_cast<const std::string&>( s2 ) ) ); 
}

int main() 
{
    std::string s1 = "abc";
    std::string s2 = "efg";

    shorterString( s1, s2 );

    std::cout << std::endl;

    shorterString( const_cast<const std::string &>( s1 ), 
                   const_cast<const std::string &>( s2 ) );

    return 0;
}

它的输出是

std::string & shorterString( std::string &, std::string ) called
const std::string & shorterString( const std::string &, const std::string ) called

const std::string & shorterString( const std::string &, const std::string ) called

Answer 2

为什么删除我以前的答案？ 我重述了我的困惑

就像我说的那样，我曾经认为引用及其引用对象在某种程度上是同一回事。 因此，对于使非常量对象与const引用参数匹配，我感到非常困惑。

并给出答案：

将参考作为一种特殊的指针。 从这个角度看，一切似乎都有意义。

这是我对这两个相关问题的结论和答案。 这可能对像我这样的新手有所帮助。

如果您真的觉得这没用，请随时删除整个问题。