전달 문제를 이해해야합니다. 전체 문제를 자세히 읽을 수 있지만 요약하겠습니다.

기본적으로 expression이 주어지면 표현식 이 동일하기를 E(a, b, ... , c)원합니다 f(a, b, ... , c). C ++ 03에서는 불가능합니다. 많은 시도가 있지만 모두 어떤 측면에서 실패합니다.

가장 간단한 방법은 lvalue-reference를 사용하는 것입니다.

template <typename A, typename B, typename C>
void f(A& a, B& b, C& c)
{
    E(a, b, c);
}

그러나 f(1, 2, 3);lvalue-reference에 바인딩 할 수 없으므로 임시 값을 처리하지 못합니다 .

다음 시도는 다음과 같습니다.

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c)
{
    E(a, b, c);
}

위의 문제는 해결하지만 플롭은 뒤집 힙니다. 이제는 E비 const 인수 를 허용하지 않습니다 .

int i = 1, j = 2, k = 3;
void E(int&, int&, int&); f(i, j, k); // oops! E cannot modify these

세 번째 시도는 const를 참조를 받아,하지만 const_cast‘는이 s의 const거리 :

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c)
{
    E(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c));
}

이것은 모든 값을 받아들이고 모든 값을 전달할 수 있지만 잠재적으로 정의되지 않은 동작으로 이어집니다.

const int i = 1, j = 2, k = 3;
E(int&, int&, int&); f(i, j, k); // ouch! E can modify a const object!

최종 솔루션은 유지 관리가 불가능한 비용으로 모든 것을 올바르게 처리합니다. 당신의 과부하를 제공 f하여, 모든 CONST 및 const가 아닌 조합 :

template <typename A, typename B, typename C>
void f(A& a, B& b, C& c);

template <typename A, typename B, typename C>
void f(const A& a, B& b, C& c);

template <typename A, typename B, typename C>
void f(A& a, const B& b, C& c);

template <typename A, typename B, typename C>
void f(A& a, B& b, const C& c);

template <typename A, typename B, typename C>
void f(const A& a, const B& b, C& c);

template <typename A, typename B, typename C>
void f(const A& a, B& b, const C& c);

template <typename A, typename B, typename C>
void f(A& a, const B& b, const C& c);

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c);

N 개의 주장에는 악몽 인 2 개의 ^N 조합이 필요합니다 . 이 작업을 자동으로 수행하고 싶습니다.

(이것은 실제로 C ++ 11에서 컴파일러가 수행하는 작업입니다.)

C ++ 11에서는이 문제를 해결할 기회가 있습니다. 한 솔루션은 기존 유형의 템플릿 공제 규칙을 수정하지만 이로 인해 많은 코드가 손상 될 수 있습니다. 따라서 다른 방법을 찾아야합니다.

해결책은 새로 추가 된 rvalue-references 를 대신 사용하는 것입니다 . rvalue-reference 유형을 추론 할 때 새로운 규칙을 도입하고 원하는 결과를 만들 수 있습니다. 결국, 우리는 지금 코드를 깨뜨릴 수 없습니다.

참조에 대한 참조를 제공하는 경우 (참고 참조는 모두 의미 에워싸는 용어 T&와 T&&, 우리는 결과 유형 알아 내기 위해 다음과 같은 규칙을 사용) :

“유형 T에 대한 참조 인 유형 TR,”cv TR에 대한 lvalue reference “유형을 작성하려는 시도는”lvalue reference to T “유형을 작성하는 반면,”rvalue reference to type cv TR”은 유형 TR을 만듭니다. “

또는 표 형식으로 :

TR   R

T&   &  -> T&  // lvalue reference to cv TR -> lvalue reference to T
T&   && -> T&  // rvalue reference to cv TR -> TR (lvalue reference to T)
T&&  &  -> T&  // lvalue reference to cv TR -> lvalue reference to T
T&&  && -> T&& // rvalue reference to cv TR -> TR (rvalue reference to T)

다음으로, 템플릿 인수 추론 : 인수가 lvalue A이면 템플릿 인수에 lvalue 참조를 A에 제공합니다. 그렇지 않으면 정상적으로 추론됩니다. 이것은 소위 범용 참조를 제공합니다 ( 포워딩 참조 는 이제 공식 참조 입니다).

이것이 왜 유용한가요? 결합하여 유형의 값 범주를 추적하는 기능을 유지합니다. lvalue 인 경우 lvalue-reference 매개 변수가 있고 그렇지 않으면 rvalue-reference 매개 변수가 있습니다.

코드에서 :

template <typename T>
void deduce(T&& x);

int i;
deduce(i); // deduce<int&>(int& &&) -> deduce<int&>(int&)
deduce(1); // deduce<int>(int&&)

마지막은 변수의 값 범주를 “전달”하는 것입니다. 함수 내부에서 매개 변수는 lvalue로 전달 될 수 있습니다.

void foo(int&);

template <typename T>
void deduce(T&& x)
{
    foo(x); // fine, foo can refer to x
}

deduce(1); // okay, foo operates on x which has a value of 1

좋지 않습니다. 우리는 우리가 얻은 것과 같은 종류의 가치 범주를 얻어야합니다! 해결책은 다음과 같습니다.

static_cast<T&&>(x);

이것은 무엇을 하는가? 우리가 deduce함수 안에 있고 lvalue가 전달되었다고 가정하십시오. 이는 Ta A&이므로 정적 캐스트의 대상 유형은 A& &&또는 A&입니다. x는 이미 이므로 A&아무 것도하지 않고 lvalue 참조가 남습니다.

rvalue, Tis 가 전달 A되면 정적 캐스트의 대상 유형은 A&&입니다. 캐스트로 인해 rvalue 표현식이 생성 되어 더 이상 lvalue reference로 전달할 수 없습니다 . 매개 변수의 값 범주를 유지했습니다.

이를 종합하면 “완벽한 전달”이됩니다.

template <typename A>
void f(A&& a)
{
    E(static_cast<A&&>(a));
}

때 f좌변를 수신, E좌변을 가져옵니다. 때 f를 rvalue를 수신 E를 rvalue를 가져옵니다. 완전한.

그리고 물론, 우리는 못생긴 것을 제거하고 싶습니다. static_cast<T&&>기이하고 기억하기가 이상합니다. 대신이라는 유틸리티 함수를 만들어 봅시다 forward.

std::forward<A>(a);
// is the same as
static_cast<A&&>(a);

답변

#include <iostream>
#include <string>
#include <utility>

void overloaded_function(std::string& param) {
  std::cout << "std::string& version" << std::endl;
}
void overloaded_function(std::string&& param) {
  std::cout << "std::string&& version" << std::endl;
}

template<typename T>
void pass_through(T&& param) {
  overloaded_function(std::forward<T>(param));
}

int main() {
  std::string pes;
  pass_through(pes);
  pass_through(std::move(pes));
}

std::string& version
std::string&& version

void inner(int &,  int &);  // #1
void inner(int &&, int &&); // #2

outer(17,29);

#include <iostream>

using namespace std;

void g(const int&)
{
    cout << "const int&\n";
}

void g(int&)
{
    cout << "int&\n";
}

void g(int&&)
{
    cout << "int&&\n";
}

template <typename T>
void f(T&& a)
{
    g(static_cast<T&&>(a));
}

int main()
{
    cout << "f(1)\n";
    f(1);
    int a = 2;
    cout << "f(a)\n";
    f(a);
    const int b = 3;
    cout << "f(const b)\n";
    f(b);
    cout << "f(a * b)\n";
    f(a * b);
}

f(1)
int&&
f(a)
int&
f(const b)
const int&
f(a * b)
int&&

     std::forward<int>(1);
     std::forward<std::string>("Hello");