Início / user-11275087

Sam's questions

Martin Hope
sam
Asked: 2025-04-09 09:30:24 +0800 CST
  • 7

Estou trabalhando com uma classe C++ que inclui um operador de conversão e um construtor que recebe um std::initializer_list.
De acordo com Scott Meyers em "Effective Modern C++", Item 7, os compiladores preferem fortemente casar inicializadores entre chaves com construtores que aceitam std::initializer_lists. Essa preferência é tão pronunciada que pode substituir o que normalmente seria uma construção de copiar e mover, optando pelo std::initializer_listconstrutor.
No entanto, em meus testes, o operador de conversão não está sendo invocado como esperado. Imagino que o operador de cópia implícito seja invocado em vez disso. Abaixo está uma versão simplificada do código do livro de Scott Meyers:

#include <iostream>
#include <initializer_list>
#include <utility>

class Widget {
public:

    Widget(int i, bool b) {
        std::cout << "Widget(int, bool) called with values: " << i << ", " << b << std::endl;
    }

    Widget(int i, double d) {
        std::cout << "Widget(int, double) called with values: " << i << ", " << d << std::endl;
    }

    Widget(std::initializer_list<long double> il) {
        std::cout << "Widget(std::initializer_list<long double>) called with values: ";
        for (auto value : il) {
            std::cout << value << " ";
        }
        std::cout << std::endl;
    }
    operator float() const {
        std::cout << "Conversion operator to float called" << std::endl;
        // Dummy conversion logic; in a real class this would convert internal state to float
        return 0.0f;
    }
};

int main() {
    Widget w1(10, true);
    Widget w2(10, 5.0);

    Widget w3{ 10, 5.0 };
    Widget w4(10, 5.0);

    Widget w5(w4);
    Widget w6{ w4 }; // uses braces, calls
                     // std::initializer_list ctor
                     // (w4 converts to float, and float
                     // converts to long double)

    Widget w7(std::move(w4));
    Widget w8{std::move(w4) }; // uses braces, calls
                              // std::initializer_list ctor
                              // (for same reason as w6)
}

Os comentários para w6 e w8 foram copiados do livro.

saída:

Widget(int, bool) called with values: 10, 1

Widget(int, double) called with values: 10, 5

Widget(std::initializer_list<long double>) called with values: 10 5 

Widget(int, double) called with values: 10, 5
c++
Martin Hope
Sam
Asked: 2024-11-15 03:00:46 +0800 CST
  • 6

Estou experimentando decltype(auto)em um modelo de classe callable personalizado que simplifica o comportamento de std::function. Meu objetivo é manter o tipo de retorno exato, incluindo qualificadores como constância, referência etc., do objeto callable quando ele é invocado. Aqui está a versão muito simplificada da classe.

PS : C++ usa Rem vez de decltype(auto): https://en.cppreference.com/w/cpp/utility/functional/function/operator()

Eu queria saber se posso usar decltype(auto)com o mesmo efeito queR

template <typename>
class Callable;

template <typename R, typename... Args>
class Callable<R(Args...)>
{
public:
    template<typename F>
    Callable(F&& f) : func(std::forward<F>(f)) {}

    decltype(auto) operator()(Args... args) {
        return func(std::forward<Args>(args)...);
    }

private:
    std::decay_t<R(Args...)> func;
};
c++