람다 함수 오버로드

간단한 로컬 람다 함수를 오버로드하는 방법은 무엇입니까?

원래 문제의 SSE :

#include <iostream>
#include <map>

void read()
{
    static std::string line;
    std::getline(std::cin, line);

    auto translate = [](int idx)
    {
        constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
        return table[idx];
    };

    auto translate = [](char c)
    {
        std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3},
                                             {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
        return table[c];
    };

    int r = translate(static_cast<int>(line[0]));
    int c = translate(static_cast<char>(line[1]));
    std::cout << r << c << std::endl;
}

int main()
{
    read();
    return 0;
}

오류 메시지

error: conflicting declaration 'auto translate'
note: previous declaration as 'read()::<lambda(int)> translate'

사용자 입력을 확인하지 않아도됩니다. 이것은 SSE입니다.

아니요, 람다에 과부하가 걸리지 않습니다!

람다는 익명 펑 (즉, 익명 함수 객체), 그리고 간단한 기능을합니다. 따라서 해당 객체를 오버로드 할 수 없습니다. 당신이 기본적으로하려고하는 것은 거의

struct <some_name>
{
    int operator()(int idx) const
    {
        return {}; // some int
    }
}translate; // >>> variable name

struct <some_name>
{
    int operator()(char idx) const
    {
        return {}; // some int
    }
}translate; // >>> variable name

동일한 변수 이름을 C ++에서 재사용 할 수 없으므로 불가능합니다.

그러나에 17 C ++ 우리가 if constexpr하는 일이 컴파일시에 사실 수있는 유일한 지점을 인스턴스화 할 수 있습니다.

가능한 해결책은 다음과 같습니다.

• 단일 variabe 템플릿 람다. 또는
• 일반적인 람다 및 사용하여 매개 변수의 유형을 찾을 수 decltype 에 대한 if constexpr확인. (크레딧 @NathanOliver )

variabe 템플릿 을 사용하면 다음과 같은 작업을 수행 할 수 있습니다. ( 온라인 라이브 데모 참조 )

#include <type_traits> // std::is_same_v

template<typename T>
constexpr auto translate = [](T idx) 
{
    if constexpr (std::is_same_v<T, int>)
    {
        constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
        return table[idx];
    }
    else if constexpr (std::is_same_v<T, char>)
    {
        std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3}, {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
        return table[idx];
    }
};

그리고 그것을 이렇게 부르십시오

int r = translate<int>(line[0]);
int c = translate<char>(line[1]);

c ++ 14 이후 일반적인 람다를 사용 하면 위의 내용은 다음과 같습니다 ( 온라인 라이브 데모 참조 )

#include <type_traits> // std::is_same_v

constexpr auto translate = [](auto idx) 
{
    if constexpr (std::is_same_v<decltype(idx), int>)
    {
        constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
        return table[idx];
    }
    else if constexpr (std::is_same_v<decltype(idx), char>)
    {
        std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3}, {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
        return table[idx];
    }
};

지금처럼 람다를 호출하십시오.

int r = translate(static_cast<int>(line[0]));
int c = translate(static_cast<char>(line[1]));

Lambdas는 기본적으로 로컬로 정의 된 functors의 구문 설탕입니다. 내가 아는 한, 다른 매개 변수로 호출되도록 과부하되지 않았습니다. 모든 람다 식은 다른 유형이므로 즉각적인 오류를 제외하고는 코드가 의도 한대로 작동하지 않습니다.

그러나 과부하가있는 functor를 정의 할 수 있습니다 operator(). 가능하다면 람다에서 얻을 수있는 것입니다. 간결한 구문을 얻지 못합니다.

다음과 같은 것 :

void read()
{
    static std::string line;

    struct translator {
          int operator()(int idx) { /* ... */ }
          int operator()(char x)  { /* ... */ }
    };
    translator translate;


    std::getline(std::cin, line);

    int r = translate(static_cast<int>(line[0]));
    int c = translate(static_cast<char>(line[1]));

    std::cout << r << c << std::endl;
}

따라서 이름을 오버로드하는 규칙은 특정 종류의 함수 이름 조회 (무료 및 메서드) 에만 적용됩니다 .

람다는 함수가 아니라 함수 호출 연산자가있는 객체입니다. 따라서 두 개의 다른 람다 사이에 과부하가 발생할 수 없습니다.

이제 함수 객체로 작업하기 위해 오버로드 해상도를 얻을 수 있지만 단일 객체 범위 내에서만 가능합니다. 그리고 둘 이상이 있으면 operator()과부하 해결 이 둘 사이에서 선택할 수 있습니다.

그러나 람다는 하나 이상을 가질 수있는 확실한 방법이 없습니다 operator(). 우리는 우리 를 돕기 위해 간단한 ( c ++ 17 ) 유틸리티 클래스를 작성할 수 있습니다 :

template<class...Fs>
struct overloaded : Fs... {
  using Fs::operator()...;
};

공제 가이드 :

template<class...Fs>
overloaded(Fs...) -> overloaded<Fs...>;

이 두 가지를 사용하면 두 개의 람다를 오버로드 할 수 있습니다.

static std::string line;
std::getline(std::cin, line);

auto translate_int = [](int idx){
    constexpr static int table[8] {7,6,5,4,3,2,1,0};
    return table[idx];
};

auto translate_char = [](char c) {
    std::map<char, int> table { {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3},
                                {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
    return table[c];
};
auto translate = overloaded{ translate_int, translate_char };

int r = translate(static_cast<int>(line[0]));
int c = translate(static_cast<char>(line[1]));

그리고 완료.

쓰기 overloaded는 c ++ 14 와 c ++ 11에서 가능 하지만 더 많은 작업이 필요하고 덜 우아합니다. 문제를 알고 나면 C ++ 기능의 방식으로 특정 컴파일러가 지원하는 것과 일치하는 솔루션을 찾는 것이 어렵지 않습니다.