C++ Sobrecarga de operador não convencional

[Bimetal]

Olá pessoal. Eu me deparei com um tipo de “sobrecarga de operador”(ou talvez uma sobrecarga de um tipo primitivo) que foge da sintaxe comum(tipo operator símbolo(parâmetro)). Vou deixar um exemplo abaixo pra ficar mais claro.

 

#include <iostream>

class Valor
{
private:
    int valor;

public:
    explicit Valor(int valor);

    operator int*();
};

Valor::Valor(int valor)
{
    this->valor = valor;
}

Valor::operator int*()
{
    int* val = new int;

    *val = valor;

    return val;
}

int main()
{
    Valor dois(2);

    int* val;

    val = dois;

    std::cout << "Valor: " << *val;
}

 

As minhas dúvidas são as seguintes: esta é uma sobrecarga de um tipo primitivo? Como é possível uma função de sobrecarga sem um tipo de retorno retornar um tipo? Como foi possível atribuir o objeto ao tipo inteiro sem a sobrecarga do operador de atribuição(=)? É necessário este tipo de sobrecarga retornar um ponteiro sempre? Como funciona este tipo de sobrecarga exatamente?

 

Achei muito interessante esse tipo de sobrecarga e eu não a conhecia. Quem puder me esclarecer eu agradeço.

[João Vitor Sacramento Rocha]

14 horas atrás, Bimetal disse:

Olá pessoal. Eu me deparei com um tipo de “sobrecarga de operador”(ou talvez uma sobrecarga de um tipo primitivo) que foge da sintaxe comum(tipo operator símbolo(parâmetro)). Vou deixar um exemplo abaixo pra ficar mais claro.

 

#include <iostream>

class Valor
{
private:
    int valor;

public:
    explicit Valor(int valor);

    operator int*();
};

Valor::Valor(int valor)
{
    this->valor = valor;
}

Valor::operator int*()
{
    int* val = new int;

    *val = valor;

    return val;
}

int main()
{
    Valor dois(2);

    int* val;

    val = dois;

    std::cout << "Valor: " << *val;
}

 

As minhas dúvidas são as seguintes: esta é uma sobrecarga de um tipo primitivo? Como é possível uma função de sobrecarga sem um tipo de retorno retornar um tipo? Como foi possível atribuir o objeto ao tipo inteiro sem a sobrecarga do operador de atribuição(=)? É necessário este tipo de sobrecarga retornar um ponteiro sempre? Como funciona este tipo de sobrecarga exatamente?

 

Achei muito interessante esse tipo de sobrecarga e eu não a conhecia. Quem puder me esclarecer eu agradeço.

o tipo e da class valor  e o tipo classe recomendo estuda poo para entender melhor

[Bimetal]

@João Vitor Sacramento Rocha Como assim o tipo é da classe Valor? Como isso foi definido? E o que eu tenho que estudar exatamente pra entender isso? POO abrange muita coisa.

[arfneto]

16 horas atrás, Bimetal disse:

Eu me deparei com um tipo de “sobrecarga de operador”(ou talvez uma sobrecarga de um tipo primitivo) que foge da sintaxe comum(tipo operator símbolo(parâmetro))

 

Olá

 

Não entendi o propósito desse código. O que pretende fazer? Tem algum contexto disso? Algum detalhe?

 

Não existe sobrecarga de tipo primitivo, apenas de operadores quando usados com classes definidas pelo usuário. E a sintaxe é única. 

 

Nesse caso o que está redefinindo é o (int*)(x) onde x é da classe Valor. E do modo como está declarado trata-se do operador unário, como seria em x++ ou *x. A sintaxe define o modo de uso.

 

Aumentei um pouco seu exemplo a seguir, usando polimorfismo no overload do operador *

 

Veja esse resultado

 overload *
Valor: 2
 overload *
outro Valor: 34
 overload *
outro  Valor: 35
 overload double *
double: 34.56

Para esse programa

#include <iostream>

using namespace std;

class Valor
{
private:
    int valor;
    double dValue;

public:
    explicit Valor(int valor);

    operator int* ();
    operator double* ();

public:
    void setValor(int v) { valor = v; };

};

Valor::Valor(int valor)
{
    this->valor = valor;
    dValue = 34.56;
}

Valor::operator int* ()
{
    int* val = new int;

    *val = valor;
    cout << " overload * " << endl;
    return val;
}

Valor::operator double* ()
{
    double* val = new double;

    *val = dValue;
    cout << " overload double * " << endl;
    return val;
}


int main()
{
    Valor dois(2);
    Valor outro(34);

    int* val;

    val = dois;
    std::cout << "Valor: " << *val << endl;

    val = (int*)outro;
    std::cout << "outro Valor: " << *val << endl;

    outro.setValor(35);
    val = (int*)outro;
    std::cout << "outro  Valor: " << *val << endl;

    double d = *((double*)outro);
    std::cout << "double: " << d << endl;

};

Em especial, veja essa linha:

 

    double d = *((double*)outro);

E veja que no código o (double*) foi redefinido para a classe Valor, mas deve ser usado normalmente para double...

Espero que ajude a entender.

 

Note que esse código não serve para nada. Aloca um valor que não tem como liberar depois e não parece servir a nenhum propósito a não mostrar algo esquisito...
 

 

 

[V!OLADOR]

@Bimetal Suponha que você queira converter de um tipo float (m) para int (n) em C++, escreveria-se algo do tipo:

float m = 3.14f;
int n = int(m);

 

A variável n agora vale 3. E isto é possivel em C++ graças ao operador de conversão:

 

operator int()

 

Note bem, não estamos falando do tipo int mas de uma função com interface int() que retorna o tipo int. No teu exemplo você sobrecarregou um operador de conversão do tipo Valor pro tipo int*.

[Bimetal]

Agora entendi. Então este tipo de função de sobrecarga faz com que, na atribuição, haja uma espécie de "casting" implícito do tipo da classe para o tipo atribuído. Embora eu tivesse o mesmo efeito prático se eu sobrecarregasse o operador de atribuição(=). Obrigado, pessoal.

[arfneto]

5 horas atrás, Bimetal disse:

este tipo de função de sobrecarga faz com que, na atribuição, haja uma espécie de "casting" implícito do tipo da classe para o tipo atribuído.

 

Olá

 

Imagino que tenha lido o programa de exemplo que deixei acima. 
 

A julgar pela documentação em https://en.cppreference.com/w/cpp/language/cast_operator isso é tido como user-defined conversion ou cast operator e não é uma função de sobrecarga. Mas é sim um cast. Veja o início do artigo
 

 

5 horas atrás, Bimetal disse:

Embora eu tivesse o mesmo efeito prático se eu sobrecarregasse o operador de atribuição(=)

 

Não entendi como teria algo similar usando overload do operador de atribuição. Nesse caso de exemplo tem um tipo primitivo do lado esquerdo então não há essa possibilidade.