C++模板函数中两种类型转换写法是否完全等价？

Great question—this is one of those subtle C++ details that looks trivial at first but has important edge cases. Let's break down whether your two versions are equivalent, and where they diverge.

First, let's clarify what each version is doing under the hood:

• Version 1 (S s = t; return s;): This uses copy initialization. The compiler tries to convert t into an instance of S through implicit conversion paths, then copies (or moves) that into s—though modern compilers will almost always optimize away the copy/move via copy elision.
• Version 2 (return S(t);): This uses direct initialization. It directly constructs an S instance using the constructor that matches t's type, with no implicit conversion step forced by the initialization syntax.

They are not 100% equivalent—here are the key scenarios where they differ:

1. When S has an explicit constructor #

This is the most common and impactful difference. explicit constructors are designed to block implicit conversions, which means they can't be used in copy initialization.

For example:

struct S {
    explicit S(int) {} // Marked explicit
};

template<typename T, typename S>
S my_function(T t) {
    // Version 1: Compile error!
    // S s = t; // Can't use explicit constructor for implicit conversion
    // Version 2: Works perfectly
    return S(t); // Directly calls the explicit constructor
}

If your codebase uses explicit constructors anywhere for S types, switching to version 1 would break compilation, while version 2 remains valid.

2. When multiple implicit conversion paths exist #

Suppose there's an implicit conversion from T to some type U, and S has both a constructor accepting T (marked explicit) and a constructor accepting U (not explicit).

• Version 1 will prioritize the implicit conversion to U, then use the non-explicit constructor S(U) to create the instance.
• Version 2 will directly use the explicit S(T) constructor, skipping the T→U conversion.

Example:

struct U {};
U operator+(int) { return U{}; } // Implicit conversion from int to U

struct S {
    explicit S(int) {}
    S(U) {} // Non-explicit
};

// When T = int:
S version1(int t) {
    S s = t; // Uses int→U conversion, then S(U)
    return s;
}

S version2(int t) {
    return S(t); // Directly uses explicit S(int)
}

This leads to different instances being created, depending on which constructor is called.

3. Copy elision edge cases #

While modern compilers will almost always eliminate the copy/move in version 1 (turning it into something equivalent to version 2), copy elision is an optimization, not a requirement. In rare cases (like when compiling without optimizations, or in scenarios where elision isn't allowed), version 1 might incur a copy/move operation that version 2 avoids. Though this is usually a performance concern rather than a correctness one.

Bottom Line #

If your codebase never uses explicit constructors for the S types in question, and there are no ambiguous implicit conversion paths, the two versions will behave identically in practice. But if either of those edge cases applies, they are not interchangeable.

My advice: If you want to ensure you can always call the constructor directly (and avoid implicit conversion surprises), stick with version 2 (return S(t);). It's more explicit (pun intended) about your intent and works in all scenarios where version 1 would, plus some.

内容的提问来源于stack exchange，提问作者Beginner