c ++ std :: function тип проверки корректен? - PullRequest
Новая
       13

c ++ std :: function тип проверки корректен?

3 голосов
/ 04 марта 2020

I sh для использования std :: function type, чтобы сигнатура функции проверялась при назначении. Но я не понимаю, что происходит в этом случае 

//g++  5.4.0
#include <iostream>
#include <functional>
int f(int x)      { std::cout << "//f:int->int\n";    return x; }
int g(double x)   { std::cout << "//g:double->int\n"; return 1; }
int main()
{
    std::function<int(int)> fct;
    fct = f; fct(1);
    fct = g; fct(1);
}
//trace
//
//f:int->int
//g:double->int

Мне нужно поведение для f, но я подумал, что "fct = g;" может привести к ошибке времени компиляции.

Есть ли какие-либо сведения об этом случае, пожалуйста?

Ответы [ 3 ]

2 голосов
/ 04 марта 2020

std::function принимает любой вызываемый объект, где параметры могут быть преобразованы, а тип возвращаемого значения может быть преобразован. Если это не так, вы получаете ошибку компиляции. Например: 

int h(double& x);

std::function<int(int)> fct;
fct = h; // <- compiler error
1 голос
/ 04 марта 2020

std::function является гибким и использует type erasure снизу, поэтому, если у вас есть std::function объект с подписью std::function<R(Args...)>, он примет любой Callable, который может быть вызван с типом Args..., и вернет тип R,

Так что в вашем случае для std::function<int(int)>, функция типа int g(double); может быть вызвана с типом int аргумент, компилятор просто переведет int в double,

Если вы запустите этот код 

#include <iostream>
#include <functional>
int f(int x)      { std::cout << x << " " << "//f:int->int\n";    return x; }
int g(double x)   { std::cout << x << " " << "//g:double->int\n"; return 1; }
int main()
{
    std::function<int(int)> fct;
    fct = f; fct(1);
    fct = g; fct(2.5);
}

Вы увидите, что fct примет только int, а затем компилятор увеличит его до double, поэтому при выводе fct(2.5); он напечатает 2 //g:double->int а не 2.5 //g:double->int

0 голосов
/ 04 марта 2020

чтобы завершить ответ от @gaurav, завершите сценарии, используя неявное преобразование (меня это удивило, поэтому я добавляю его всем, кому интересно) 

//g++  5.4.0
#include <iostream>
#include <functional>

class C{ 
    public : 
    int i; 
    C(int _i) : i(_i)  { std::cout << "//C::C(int " << i << ")\n"; } 
};
class D{ 
    public : 
    int i; 
    D(int _i) : i(_i)  { std::cout << "//D::D(int " << i << ")\n"; }
    D(C c)    : i(c.i) { std::cout << "//implicit conversion D::D(C " << c.i << ")\n"; }
};

int f(C c)   { std::cout << "//f:C->int : "; return c.i; }
int g(D d)   { std::cout << "//g:D->int : "; return d.i; }

int main()
{
    {
        std::cout << "//--- test implicit conversion\n";
        C c(1); 
        D d(2);
        d=c;
    }
    {
        std::function<int(C)> fct; C c(1); D d(2);
        std::cout << "//direct calls\n";
        std::cout <<   f(c) << "\n";
        // std::cout << "//" <<   f(d) << "\n";  // no conversion D->C provided by class C -->> error: could not convert ‘d’ from ‘D’ to ‘C’
        std::cout <<   g(d) << "\n";         
        std::cout <<   g(c) << "\n";             // implicit conversion, then g:D->int
    }
    {
        std::cout << "//case function:C->int\n";
        std::function<int(C)> fct; C c(1); D d(2);
        fct = f; std::cout << "//" << fct(c) << "\n";
        //std::cout << "//" << fct(d) << "\n";   // no conversion D->C provided by class C -->> error: could not convert ‘d’ from ‘D’ to ‘C’
        fct = g; std::cout << "//" << fct(c) << "\n";
        //std::cout << "//" << fct(d) << "\n";   // no conversion D->C provided by class C -->> no match for call to ‘(std::function<int(C)>) (D&)’
    }
    {
        std::cout << "//appels via function : D -> int\n";
        std::function<int(D)> fct; C c(1); D d(2);
        //fct = f;    // conversion D->C would be meaningless to f
                      // -->> error: no match for ‘operator=’ (operand types are ‘std::function<int(D)>’ and ‘int(C)’)
        fct = g; std::cout << "//" << fct(d) << "\n";
        std::cout << "//" << fct(c) << "\n";      // implicit conversion, then g:D->int
    }
}

//trace
//
//--- test implicit conversion
//C::C(int 1)
//D::D(int 2)
//implicit conversion D::D(C 1)
//C::C(int 1)
//D::D(int 2)
//direct calls
//f:C->int : 1
//g:D->int : 2
//implicit conversion D::D(C 1)
//g:D->int : 1
//case function:C->int
//C::C(int 1)
//D::D(int 2)
//f:C->int : //1
//implicit conversion D::D(C 1)
//g:D->int : //1
//appels via function : D -> int
//C::C(int 1)
//D::D(int 2)
//g:D->int : //2
//implicit conversion D::D(C 1)
//g:D->int : //1
...