Inicializando uma variável de tipo desconhecido por meio de construtores sobrecarregados em C ++

vindo de um background principalmente python, eu tenho um pouco de dificuldade em trabalhar com tipos em C ++.

Estou tentando inicializar uma variável de classe por meio de um dos vários construtores sobrecarregados que usam tipos diferentes como parâmetros. Eu li que o uso da autopalavra - chave pode ser usado para declaração automática de uma variável, no entanto, no meu caso, não será inicializado até que um construtor seja escolhido. No entanto, o compilador não está satisfeito por não inicializar value.

class Token {
public:

    auto value;

    Token(int ivalue) {
        value = ivalue;
    }
    Token(float fvalue) {
        value = fvalue;
    }
    Token(std::string svalue) {
        value = svalue;
    }

    void printValue() {
        std::cout << "The token value is: " << value << std::endl;
    }
};

Em python, isso pode se parecer com:

class Token():
        def __init__(self, value):
             self.value = value

        def printValue(self):
             print("The token value is: %s" % self.value)

Qual é a maneira correta de usar a autopalavra - chave nesse cenário? Devo usar uma abordagem completamente diferente?

Inicializando uma variável de tipo desconhecido por meio de construtores sobrecarregados em C ++

Não existe "variável de tipo desconhecido" em C ++.

Qual é a maneira correta de usar a palavra-chave automática nesse cenário?

variáveis ​​deduzidas automaticamente têm um tipo deduzido do inicializador. Se não houver inicializador, não será possível usar automático. auto não pode ser usado para uma variável de membro não estático. Uma instância de uma classe não pode ter membros de tipo diferente de outra instância.

Não há como usar a palavra-chave automática neste cenário.

Devo usar uma abordagem diferente completamente?

Provavelmente. Parece que você está tentando implementar um std::variant. Se você precisar de uma variável para armazenar um número X de tipos, é isso que você deve usar.

No entanto, você pode estar tentando emular a digitação dinâmica em C ++. Embora possa ser familiar para você devido à experiência com o Python, em muitos casos essa não é a abordagem ideal. Por exemplo, neste programa de exemplo específico, tudo o que você faz com a variável membro é imprimi-lo. Portanto, seria mais simples armazenar uma string em cada caso. Outras abordagens são o polimorfismo estático, como mostrado pelo polimorfismo dinâmico no estilo Rhathin ou OOP, como mostrado pelo Fire Lancer.

C ++ é uma linguagem de tipo estaticamente , o que significa que todos os tipos de variáveis ​​são determinados antes do tempo de execução. Portanto, autopalavra-chave não é algo como varpalavra-chave em javascript, que é uma linguagem de tipo dinâmico. autoA palavra-chave é comumente usada para especificar tipos desnecessariamente complexos.

O que você está procurando pode ser feito usando a classe de modelo C ++, o que permite criar várias versões da classe que usa tipos diferentes.

Esse código pode ser a resposta que você está procurando.

template <typename T>
class Token {
private:
    T value;

public:
    Token(const T& ivalue) {
        value = ivalue;
    }

    void printValue() {
        std::cout << "The token value is: " << value << std::endl;
    }
};

Esse código seria compilado se algumas condições fossem atendidas, como a função operator<<deve ser definida para std :: ostream & e tipo T.

Uma abordagem diferente da que outros propuseram é usar modelos. Aqui está um exemplo:

template<class T>
class Token {
public:

    T value;

    Token(T value) :
        value(std::move(value))
    {}

    void printValue() {
        std::cout << "The token value is: " << value << std::endl;
    }
};

Então você pode usar sua classe assim:

Token<int> x(5);
x.printValue();

Você pode usar o std::varianttipo O código abaixo mostra uma maneira (mas é um pouco desajeitado, devo admitir):

#include <iostream>
#include <variant>

class Token {
public:

    std::variant<int, float, std::string> value;

    Token(int ivalue) {
        value = ivalue;
    }
    Token(float fvalue) {
        value = fvalue;
    }
    Token(std::string svalue) {
        value = svalue;
    }

    void printValue() {
        switch (value.index()) {
            case 0:
                std::cout << "The token value is: " << std::get<0>(value) << std::endl;
                break;
            case 1:
                std::cout << "The token value is: " << std::get<1>(value) << std::endl;
                break;
            case 2:
                std::cout << "The token value is: " << std::get<2>(value) << std::endl;
                break;
        }
    }
};

int main() {
    Token it(1);
    Token ft(2.2f);
    Token st("three");
    it.printValue();
    ft.printValue();
    st.printValue();
    return 0;
}

Seria muito melhor se o std::get<0>(value)poderia ser escrito como std::get<value.index()>(value), mas, infelizmente, o "x" in <x>deve ser uma expressão constante em tempo de compilação.

auto deve ser dedutível para um tipo específico, não fornece digitação dinâmica em tempo de execução.

Se, no momento da declaração, Tokenvocê souber todos os tipos possíveis, poderá usar std::variant<Type1, Type2, Type3>etc. Isso é semelhante a ter um "tipo enum" e uma "união". Isso garante que os construtores e destruidores adequados sejam chamados.

std::variant<int, std::string> v;
v = "example";
v.index(); // 1, a int would be 0
std::holds_alternative<std::string>(v); // true
std::holds_alternative<int>(v); // false
std::get<std::string>(v); // "example"
std::get<int>(v); // throws std::bad_variant_access

Uma alternativa poderia ser criar um Tokensubtipo diferente para cada caso (possivelmente usando modelos) com métodos virtuais adequados.

class Token {
public:
    virtual void printValue()=0;
};

class IntToken : public Token {
public:
    int value;
    IntToken(int ivalue) {
        value = ivalue;
    }
    virtual void printValue()override
    {
        std::cout << "The token value is: " << value << std::endl;
    }
}

A solução abaixo é semelhante em espírito à da resposta de Fire Lancer. A principal diferença é que segue o comentário possivelmente usando modelos e, assim, elimina a necessidade de criar instâncias derivadas explicitamente da interface. Tokennão é ela mesma a classe de interface. Em vez disso, define a interface como uma classe interna e uma classe de modelo interna para automatizar a definição das classes derivadas.

Sua definição parece excessivamente complexa. No entanto, Token::Basedefine a interface e Token::Impl<>deriva da interface. Essas classes internas estão totalmente ocultas para o usuário de Token. O uso seria semelhante a:

Token s = std::string("hello");
Token i = 7;

std::cout << "The token value is: " << s << '\n';
std::cout << "The token value is: " << i << '\n';

Além disso, a solução abaixo ilustra como alguém pode implementar um operador de conversão para atribuir uma Tokeninstância a uma variável regular. Depende dynamic_caste lançará uma exceção se o elenco for inválido.

int j = i; // Allowed
int k = s; // Throws std::bad_cast

A definição de Tokenestá abaixo.

class Token {

    struct Base {
        virtual ~Base () = default;
        virtual std::ostream & output (std::ostream &os) = 0;
    };

    template <typename T>
    struct Impl : Base {
        T val_;
        Impl (T v) : val_(v) {}
        operator T () { return val_; }
        std::ostream & output (std::ostream &os) { return os << val_; }
    };

    mutable std::unique_ptr<Base> impl_;

public:

    template <typename T>
    Token (T v) : impl_(std::make_unique<Impl<T>>(v)) {}

    template <typename T>
    operator T () const { return dynamic_cast<Impl<T>&>(*impl_); }

    friend auto & operator << (std::ostream &os, const Token &t) {
        return t.impl_->output(os);
    }
};

Experimente online!