如果我们用一个构造函数转换一个值，是否还需要复制构造函数来复制新创建的临时 object？

Question

I am having a trouble understanding the topic, and so it might be a stupid question but I am still wondering:

When we have a function, for example:

void func(const StringClass & param1, const StringClass & param2);

And then we pass to the function for example, a C string:

func("test", test);

Where "test" is a C string and test is an object of our StringClass . And let's say our StringClass has defined a copy constructor and also a conversion constructor which can convert our "test" C string into a StringClass object. I have tested it already and what I have seen is that, that there is only conversion happening and not copying, and for the other object there is only assignment which I understand, since we pass it by reference. If our function is declared like this:

void func(const StringClass param1, const StringClass param2);

And we still pass previous arguments func("test", test) , then the first argument gets converted, but no copy constructor is invoked. And for the second parameter copy constructor is invoked.

But my question is - will it always be like that? I mean, can other compiler treat it like that: convert the "test" C string into a StringClass object and then use the copy constructor to copy the temp object to param argument inside the function, or a conversion is enough since it creates a temp object anyways, so it won't differ between compilers?

Answer 1

As a first hint you can add a copy constructor that prints something to see if it gets called:

#include <iostream>

struct foo {
    template <size_t n>
    foo(const char(&str)[n]){
        std::cout << "converting constructor\n";
    }
    foo(const foo& f){
        std::cout << "copy constructor\n";
    }
};

void bar(foo){}

int main() {
    bar("asdf");
}

Output is :

converting constructor

No copy constructor is called in this example. This is only a hint, because it is the output with one specific compiler and one specific C++ standard. However, once a foo has been created by calling the converting constructor, there is no reason to call the copy constructor. The string literal "asdf" is converted to a foo and thats it. There is no additional copy in the code, hence no compiler should create another copy.