Início / coding / Perguntas / 79487186
Accepted
CuriousSoul
Asked: 2025-03-06 01:01:12 +0800 CST

Como armazenar o operador std::complex como uma variável (C++)

  • 772

Tenho escrito alguns testes para aritmética de números complexos.

Tentei escrevê-los de uma forma em que não preciso reescrever uma seção de código para cada operador. Estou tentando armazenar std::complexoperadores sobrecarregados como operator+, operator+=, operator-, operator-=em uma std::functionvariável. A razão pela qual preciso dos std::complexoperadores é porque preciso verificá-los em relação à minha própria implementação de números complexos.

No entanto, não consigo fazê-lo funcionar, principalmente porque parece haver uma incompatibilidade entre o tipo da variável ( std::function) e o tipo do valor ( std::complexoperadores). Como devo escrever o código para poder armazenar essas funções de operador em uma std::functionvariável?

Esta é minha tentativa, mas infelizmente não funciona:

std::function<void(std::complex<double>&, const std::complex<double>&)> var = 
                                               &std::complex<double>::operator+=;
c++

3 respostas

  1. Use uma expressão lambda:

    std::function<void(std::complex<double>&, const std::complex<double>&)> var = 
          [](std::complex<double>& a,const std::complex<double>& b) {
                 a+=b;
          };

    Note que operator+=não retorna void. Para manter a semântica de +=altere o lambda para return a+=b;e especifique seu tipo de retorno como std::complex<double>&.

    • 4

  2. Existem <functional>objetos de função genéricos para quase todos os operadores C++, atribuição ecxept e suas contrapartes compostas, addressof, dereference e index:

    #include <functional>
#include <complex>

using complex_f = std::complex<float>;
using fn_t = 
      std::function<void(complex_f&, complex_f const&)>;

fn_t add_fn = std::plus<>{};
fn_t multiply_fn = std::multiplies<>{};

    Entretanto, para operadores com classes std ausentes, você precisa usar lambdas:

    auto constexpr add_assign =
[](auto& dst, auto const& src)
->decltype(auto)
{ return dst += src; };

fn_t increase_fn = add_assign;

    funções e funções membro definidas na biblioteca padrão e suas classes têm tipos não especificados. Elas apenas carregam o nome de função e não devem ser assumidas como estritamente funções. Como tal, tentar armazenar seus endereços como ponteiros de função da velha escola é UB.

    No meu último snippet, primeiro defini um lambda genérico nomeado, então inicializei um std::functioncom esse lambda. Isso torna possível comparar de forma confiável instâncias de std::functionusando sua targetfunção de template de membro:

    auto const fn_tgt
   = increase_fn.target<decltype(add_assign)>);
assert((nullptr!=fn_tgt);

    Se um lambda sem nome fosse usado, tal teste não estaria disponível. Porque cada instância lambda tem um identificador de tipo distinto exclusivo.

    • 1
  3. Best Answer

    Você deve verificar a documentação do std::complex::operator+=.

    Observe que a versão do modelo tem apenas uma sobrecarga:

    constexpr complex& operator+=( const T& other ); // (1)

    que não corresponde ao seu caso (você está esperando o tipo de argumento const std::complex<T>&).

    Agora, se você der uma olhada mais abaixo no documento, verá outra versão de modelo de operator+=:

    template<class X>
constexpr complex& operator+=( const std::complex<X>& other ); // (5)

    Então você precisa disto para que funcione:

    std::function<void(std::complex<double>&, const std::complex<double>&)> var = 
                                               &std::complex<double>::operator+=<double>;

    Observe o extra <double>!

    https://godbolt.org/z/TPGMe435s

    Observe que esse operador também deve funcionar ao adicionar std::complexcom diferentes tipos de base, é por isso que o modelo de função membro é necessário, então std::complex<float>ele std::complex<double>pode ser adicionado.

    • -2

relate perguntas