Question

我试图从初学者的书中理解以下代码。（编辑：“使用c ++进行编程的原理和实践”，第1085页）我不太明白为什么要根据注释创建临时字符串。

const char* string_tbl[ ] = { "Mozart", "Grieg", "Haydn", "Chopin" };
const char* f(int i) { return string_tbl[i]; }
void g(string s){}

void h()
{
    const string& r = f(0);  // bind temporary string to r
    g(f(1));                 // make a temporary string and pass it
    string s = f(2);         // initialize s from temporary string
    cout << "f(3): " << f(3) // make a temporary string and pass it
    <<" s: " << s
    << " r: " << r << '\n';
}

f()返回一个指向const char的指针，对吧？

不应const string& r = f(0);为参考变量分配“指向char的指针”（在这种情况下为全局数组中的字符串文字），以便可以使用r [（只读）访问原始对象。 ]等？

和g(f(1));传递一个指向g()的指针，然后用该指针初始化string s？

我想念什么？从函数返回const char *时，总是会产生一个临时字符串吗？

Answer 1

有一个隐式转换，代码

string s = f(2);

等于

string s = string(f(2));

Answer 2

我不太明白为什么要根据注释创建临时字符串。

整个问题是char const*和std::string是完全不同的数据类型。

为进行比较：

class A { };
class B { };
void f(A a);
void g()
{
    B b;
    f(b); // does not work...
}

我很确定你已经遇到了。

现在让我们更改A类：

class A
{
public:
    A() { }    // default constructor
    A(B b) { } // accepting an instance of B
};

现在，您可以这样做：

B b;
f(A(b)); // create a TEMPORARY A from B; you need it, as f ONLY accepts an A!
f(b);    // again, create a temporary just as before - this time IMPLICITLY

您可以通过使构造函数 explicit 禁止从B隐式创建A：

class A
{
public:
    A() { }
    explicit A(B b) { } // now A cannot be created implicitly any more
};

B b;
//f(b);  // now is not accepted by compiler any more
f(A(b)); // this still works, of course

与std::string完全相同：它有一个非显式的构造函数，接受char const* ...

当以const char *返回时，为什么在这里创建临时字符串？ [Stroustrup的书籍示例]

2 个答案: