Sobrecarregando operator de saida c++[RESOLVIDO]

1. Sobrecarregando operator de saida c++[RESOLVIDO]

dark777
(usa Debian)

Enviado em 07/12/2017 - 20:18h

Pessoal estou com o seguinte codigo abaixo que converte numeros inteiros em binario

#include <algorithm> // reverse

#include <climits>   // CHAR_BIT

#include <iostream>

#include <sstream>



struct Bin 

{  

 int b;

  friend std::ostream& operator<<(std::ostream& os, const Bin& f);  



std::string binary(unsigned int n)

{

  b=n;

  //converte numero para string de bits

   std::stringstream bitsInReverse;

   //int nBits = sizeof(b) * CHAR_BIT;

   unsigned int nBits = sizeof(b) * 3;



   while (nBits-- > 0)

   {

      bitsInReverse << (b & 1);

      b >>= 1;

   }



   std::string bits(bitsInReverse.str());

   std::reverse(bits.begin(), bits.end());

   return bits;

}

}bin;





std::ostream &operator<<( std::ostream &saida, const Bin& f)

{

 saida << f.binary(f.b);

 return saida;

}



int main()

{

  //127 em binario 000001111111

   std::cout << "\n\t127 em hexadecimal: " << std::hex << 127

             << "\n\t127 em octal:       " << std::oct << 127 

             << "\n\t127 em decimal:     " << std::dec << 127 

             << "\n\t127 em binario:     " << bin << 127

             <<"\n\n";

}

se eu fizer const Bin& f ao compilar retorna o seguinte erro abaixo:

operatorBin.cxx: In function ‘std::ostream& operator<<(std::ostream&, const Bin&)’:
operatorBin.cxx:54:23: error: passing ‘const Bin’ as ‘this’ argument discards qualifiers [-fpermissive]
saida << f.binary(f.b);
^
operatorBin.cxx:31:13: note: in call to ‘std::string Bin::binary(unsigned int)’
std::string binary(unsigned int n)

agora se eu fizer Bin& f;

ele nao da o erro acima compila tranquilamente mas, ao executar ele nao converte o numero usando o operator sobrecarregado..
O que esta dando de errado?

0 0

Quote

2. Re: Sobrecarregando operator de saida c++[AJUDA]

paulo1205
(usa Ubuntu)

Enviado em 08/12/2017 - 00:44h

Problema de fundo: um ponteiro constante não pode ser convertido implicitamente para ponteiro não-constante, pois isso violaria garantias do sistema de tipos.

Como você provavelmente já sabe, toda função-membro não-estática de uma classe recebe um ponteiro para o objeto que a invocar. Esse ponteiro pode ser referido no corpo da função pelo nome this, que na prática funciona como se fosse um parâmetro oculto da função, obtido implicitamente a partir do objeto.

Numa função-membro não-qualificada (explico a seguir), o tipo do ponteiro this é "ponteiro para o tipo da classe". Então, se eu tenho o objeto x, do tipo X, e chamo a função-membro X::func() sobre o objeto x através da forma x.func(), a função vai receber pelo ponteiro this o valor de &x, cujo tipo é X*.

Contudo, se o objeto x tiver sido declarado como constante, o tipo de &x não será X*, mas sim const X*, que não pode ser convertido para o X* que X::func() esperaria receber, pois isso provocaria uma violação das garantias do sistema de tipos (imagine se a função tentasse, internamente, modificar o objeto apontado por this).

Para poder chamar funções-membros em objetos constantes, tais funções têm de ser qualificadas como constantes. Isso faz com que o tipo do ponteiro this usado por ela internamente seja do tipo const X*. Essas funções podem também ser usadas com objetos não-constantes, uma vez que é seguro que um ponteiro constante aponte para um objeto não-constante (o contrário é que não pode).

A forma de declarar uma função-membro qualificada segue a forma tradicional do C de se expressar da direita para a esquerda.

Segue abaixo o exemplo de uma classe com uma função não qualificada (não-constante e não-volátil) e outra qualificada como constante.

class X {

  private:

    std::string _str;



  public:

    void str(const std::string &nova_str){

      // Altera a string.  Função exige objeto não-constante.

      _str=nova_str;

    }



    std::string str() const {  // <--- Note o “const” após a lista de parâmetros.

      // Retorna uma cópia da string.  Não altera o objeto, que pode ser constante ou não.

      return _str;  // Gera uma cópia do valor de _str.

    }

};

Para resolver o seu problema, basta que você qualifique como constantes todas as funções que não precisem alterar o conteúdo do objeto. Essa é, inclusive, uma boa prática.

1 0

Quote

3. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

dark777
(usa Debian)

Enviado em 08/12/2017 - 16:36h

paulo1205 escreveu:

Problema de fundo: um ponteiro constante não pode ser convertido implicitamente para ponteiro não-constante, pois isso violaria garantias do sistema de tipos.

Como você provavelmente já sabe, toda função-membro não-estática de uma classe recebe um ponteiro para o objeto que a invocar. Esse ponteiro pode ser referido no corpo da função pelo nome this, que na prática funciona como se fosse um parâmetro oculto da função, obtido implicitamente a partir do objeto.

Numa função-membro não-qualificada (explico a seguir), o tipo do ponteiro this é "ponteiro para o tipo da classe". Então, se eu tenho o objeto x, do tipo X, e chamo a função-membro X::func() sobre o objeto x através da forma x.func(), a função vai receber pelo ponteiro this o valor de &x, cujo tipo é X*.

Contudo, se o objeto x tiver sido declarado como constante, o tipo de &x não será X*, mas sim const X*, que não pode ser convertido para o X* que X::func() esperaria receber, pois isso provocaria uma violação das garantias do sistema de tipos (imagine se a função tentasse, internamente, modificar o objeto apontado por this).

Para poder chamar funções-membros em objetos constantes, tais funções têm de ser qualificadas como constantes. Isso faz com que o tipo do ponteiro this usado por ela internamente seja do tipo const X*. Essas funções podem também ser usadas com objetos não-constantes, uma vez que é seguro que um ponteiro constante aponte para um objeto não-constante (o contrário é que não pode).

A forma de declarar uma função-membro qualificada segue a forma tradicional do C de se expressar da direita para a esquerda.

Segue abaixo o exemplo de uma classe com uma função não qualificada (não-constante e não-volátil) e outra qualificada como constante.

class X {

  private:

    std::string _str;



  public:

    void str(const std::string &nova_str){

      // Altera a string.  Função exige objeto não-constante.

      _str=nova_str;

    }



    std::string str() const {  // <--- Note o “const” após a lista de parâmetros.

      // Retorna uma cópia da string.  Não altera o objeto, que pode ser constante ou não.

      return _str;  // Gera uma cópia do valor de _str.

    }

};

Para resolver o seu problema, basta que você qualifique como constantes todas as funções que não precisem alterar o conteúdo do objeto. Essa é, inclusive, uma boa prática.

wiki.anon

fiz o que vc disse mas ainda assim ele nao esta convertendo em binario ele da toda saida em 00000000000

0 0

Quote

4. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

paulo1205
(usa Ubuntu)

Enviado em 11/12/2017 - 11:41h

O problema é com seu algoritmo de conversão. Tente ver de onde ele está recebendo o valor a ser convertido, e você verá que ele não chega de lugar nenhum.

1 0

Quote

5. Re: Sobrecarregando operator de saida c++[AJUDA]

dark777
(usa Debian)

Enviado em 12/12/2017 - 13:44h

paulo1205 escreveu:

O problema é com seu algoritmo de conversão. Tente ver de onde ele está recebendo o valor a ser convertido, e você verá que ele não chega de lugar nenhum.

mais é estranho pois eu uso o mesmo algoritimo de conversao em uma função e converte corretamente, mas quando coloco no operator ele nao o faz..

wiki.anon

0 0

Quote

6. Re: Sobrecarregando operator de saida c++[AJUDA]

phoemur
(usa Debian)

Enviado em 12/12/2017 - 22:03h

você não poderia utilizar std::bitset ( http://en.cppreference.com/w/cpp/utility/bitset ) para facilitar ?

por exemplo:

arquivo binary.cpp



//g++ -O2 -Wall -Wpedantic -std=c++11 -o binary binary.cpp

#include <iostream>

#include <string>

#include <bitset>

#include <type_traits>



template<typename T>

typename std::enable_if<std::is_integral<T>::value, std::string>::type

binary(const T& n){

    return std::bitset<sizeof(T)*8>(n).to_string();

}



int main()

{

    std::cout << binary(127) << std::endl;



    return 0;

}

O único porém do bitset é que o tamanho deve ser conhecido no tempo de compilação, porém do jeito que eu fiz com o template e o sizeof vai dar certo...
Aquela especialização do template ali é apenas para fazer com que a função aceite apenas inteiros...

0 0

Quote

7. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

phoemur
(usa Debian)

Enviado em 13/12/2017 - 10:18h

dark777 escreveu:

paulo1205 escreveu:

O problema é com seu algoritmo de conversão. Tente ver de onde ele está recebendo o valor a ser convertido, e você verá que ele não chega de lugar nenhum.

mais é estranho pois eu uso o mesmo algoritimo de conversao em uma função e converte corretamente, mas quando coloco no operator ele nao o faz..

wiki.anon

Sendo mais explicito, seu problema é que você não está criando uma struct Bin para converter, está passando direto um inteiro 127, veja:

std::cout << "\n\t127 em hexadecimal: " << std::hex << 127

             << "\n\t127 em octal:       " << std::oct << 127 

             << "\n\t127 em decimal:     " << std::dec << 127 

             << "\n\t127 em binario:     " << bin << 127

             <<"\n\n";

0 0

Quote

8. Re: Sobrecarregando operator de saida c++[AJUDA]

paulo1205
(usa Ubuntu)

Enviado em 13/12/2017 - 10:37h

Caro dark777,

O problema que você está tendo é que o objeto bin é construído sem um valor especificado para o campo b, o que está fazendo com que ele assuma o valor 0. Quando, posteriormente, você chama a função-membro binary(), ela vai usar esse valor de b. O valor 127, que aparece depois de o objeto bin ter sido passado a operator<<(std::ostream &, Bin &) não afeta o objeto bin de modo nenhum, mas é tão-somente aplicado ao objeto retornado por essa função, que é a própria referência a std::ostream que lhe serviu como parâmetro, por meio do operador <<.

Você aparentemente quer algo parecido com os manipuladores std::hex, std::dec e std::oct. Contudo, esses manipuladores alteram campos internos do objeto std::ostream que, por sua vez, são herdados de std::ios_base. Esses campos internos, por definição, dão ao objeto ios_base a capacidade de tratar apenas as base 16, 10 e 8, respectivamente.

Como você provavelmente não quer ter de mexer internamente na implementação de ios_base, sua solução tem de ser por meio de wrappers.

O wrapper mais óbvio seria uma função (ou objeto-função, também conhecido como functor) que recebesse um inteiro e devolvesse uma string com a representação binária desse inteiro. No código, isso ficaria com a seguinte forma.

std::cout

  << std::dec << 127 << '\n'  // Primeiro imprime o nº em decimal

  << binary(127) << '\n'  // e depois em binário.

;

Isso funcionaria, mas não ficaria com cara de manipulador.

Se você fizer muita questão de algo mais parecido com um manipulador, até dá para fazer, mas com diversas limitações, e a sua classe precisará interceptar tanto o stream de saída quanto o parâmetro a ser impresso. Um esqueleto de ideia, não testado e que certamente pode ser muito mais elaborado, segue abaixo.

#include <ostream>

#include <stdexcept>

#include <string>

#include <cstdint>



using namespace std;



class my_binary_conversion_t {

  private:

    ostream *p_out;

    friend my_binary_conversion_t &operator<<(ostream &, my_binary_conversion_t &);



  public:

    my_binary_conversion_t(): p_out(nullptr) { }



    ostream &operator<<(uintmax_t val){

      if(!p_out)

        throw logic_error("manipulator not tied to any output stream");



      string s;

      // Faz com que ‘s’ receba a representação binária de ‘val’ — pode ser

      // usando a sugestão do phoemur ou alguma outra técnica.



      ostream &out=*p_out;

      p_out=nullptr;  // Limpa o ponteiro, para evitar que se use apenas o manipulador, em lugar do stream.

      return out << s;

    }

} bin;



my_binary_conversion_t &operator<<(ostream &out, my_binary_conversion_t &wrapper){

  wrapper.p_obj=&out;

  return wrapper;  // Note que eu retorno uma referência para o wrapper, não para o stream.

}

0 0

Quote

9. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

dark777
(usa Debian)

Enviado em 13/12/2017 - 17:19h

phoemur escreveu:

você não poderia utilizar std::bitset ( http://en.cppreference.com/w/cpp/utility/bitset ) para facilitar ?

por exemplo:

arquivo binary.cpp



//g++ -O2 -Wall -Wpedantic -std=c++11 -o binary binary.cpp

#include <iostream>

#include <string>

#include <bitset>

#include <type_traits>



template<typename T>

typename std::enable_if<std::is_integral<T>::value, std::string>::type

binary(const T& n){

    return std::bitset<sizeof(T)*8>(n).to_string();

}



int main()

{

    std::cout << binary(127) << std::endl;



    return 0;

}

A questão é fazer sobrecarga de operator para que converta ja fiz um usando bitset alias tenho um algoritmo que faz varias conversoes apenas usando a std::dec, hex, oct e bitset mas estava tentando fazer a conversão atravez de um operator...
wiki.anon

0 0

Quote

10. Re: Sobrecarregando operator de saida c++[AJUDA]

dark777
(usa Debian)

Enviado em 13/12/2017 - 17:38h

paulo1205 escreveu:

Caro dark777,

O problema que você está tendo é que o objeto bin é construído sem um valor especificado para o campo b, o que está fazendo com que ele assuma o valor 0. Quando, posteriormente, você chama a função-membro binary(), ela vai usar esse valor de b. O valor 127, que aparece depois de o objeto bin ter sido passado a operator<<(std::ostream &, Bin &) não afeta o objeto bin de modo nenhum, mas é tão-somente aplicado ao objeto retornado por essa função, que é a própria referência a std::ostream que lhe serviu como parâmetro, por meio do operador <<.

Você aparentemente quer algo parecido com os manipuladores std::hex, std::dec e std::oct. Contudo, esses manipuladores alteram campos internos do objeto std::ostream que, por sua vez, são herdados de std::ios_base. Esses campos internos, por definição, dão ao objeto ios_base a capacidade de tratar apenas as base 16, 10 e 8, respectivamente.

Como você provavelmente não quer ter de mexer internamente na implementação de ios_base, sua solução tem de ser por meio de wrappers.

O wrapper mais óbvio seria uma função (ou objeto-função, também conhecido como functor) que recebesse um inteiro e devolvesse uma string com a representação binária desse inteiro. No código, isso ficaria com a seguinte forma.

std::cout

  << std::dec << 127 << '\n'  // Primeiro imprime o nº em decimal

  << binary(127) << '\n'  // e depois em binário.

;

#include <ostream>

#include <stdexcept>

#include <string>

#include <cstdint>



using namespace std;



class my_binary_conversion_t {

  private:

    ostream *p_out;

    friend my_binary_conversion_t &operator<<(ostream &, my_binary_conversion_t &);



  public:

    my_binary_conversion_t(): p_out(nullptr) { }



    ostream &operator<<(uintmax_t val){

      if(!p_out)

        throw logic_error("manipulator not tied to any output stream");



      string s;

      // Faz com que ‘s’ receba a representação binária de ‘val’ — pode ser

      // usando a sugestão do phoemur ou alguma outra técnica.



      ostream &out=*p_out;

      p_out=nullptr;  // Limpa o ponteiro, para evitar que se use apenas o manipulador, em lugar do stream.

      return out << s;

    }

} bin;



my_binary_conversion_t &operator<<(ostream &out, my_binary_conversion_t &wrapper){

  wrapper.p_obj=&out;

  return wrapper;  // Note que eu retorno uma referência para o wrapper, não para o stream.

}

Interessante porém estava pesquisando em outros forums e consegui chegar a este resultado

#include <ios> //ios_base

#include <climits>   // CHAR_BIT

#include <sstream>

#include <iostream>

#include <algorithm>  // reverse



 struct BinStream

 {

  std::string binario(unsigned int n)

   {

    //converte numero para string de bits

     std::stringstream bitsInReverse;

      //int nBits = sizeof(n) * CHAR_BIT;

       unsigned int nBits = sizeof(n)*2.5;



       while (nBits-- > 0)

       {

        bitsInReverse << (n & 1);

        n >>= 1;

       }

       

      std::string bits(bitsInReverse.str());

     std::reverse(bits.begin(), bits.end());

    return bits;

   }

 

  std::ostream& os;

  

  BinStream(std::ostream& os): os(os) {}



  

  template<class T>

  BinStream& operator<<(T& value)     

  {

   os << value;

   return *this;

  }



  BinStream& operator<<(int value)

  {

    os << binario(value);

    return *this;  

  }

/*

  std::ostream& operator<<(std::ios_base& (__cdecl *_Pfn)(std::ios_base&))

  {

   return os <<_Pfn;

  }

  */

};





struct Bin

{

 friend BinStream operator<<(std::ostream& os, const Bin& f);

}bin;





BinStream operator<<(std::ostream& os, const Bin& f)

{

 return BinStream(os);

}













int main()

{

  std::cout << "\n\t127 em decimal:     " << std::dec << 127

            << "\n\t127 em octal:       " << std::oct << 127

            << "\n\t127 em hexadecimal: " << std::hex << 127

            << "\n\t127 em binario:     " << bin << 12 << "\n\n";

}

só que esta dando erro nesta parte:

  std::ostream& operator<<(std::ios_base& (__cdecl *_Pfn)(std::ios_base&))

  {

   return os <<_Pfn;

  }

error: expected ‘,’ or ‘...’ before ‘(’ token

   std::ostream& operator<<(std::ios_base& (__cdecl *_Pfn)(std::ios_base&))

                                           ^

operatorBin2.cxx: In member function ‘std::ostream& std::BinStream::operator<<(std::ios_base&)’:

operatorBin2.cxx:49:16: error: ‘_Pfn’ was not declared in this scope

    return os <<_Pfn;

pois ela impede que sobrescreva todas as outras conversoes por ex:

  std::cout << "\n\t127 em binario:     " << bin << 127

            << "\n\t127 em octal:       " << std::oct << 127

            << "\n\t127 em hexadecimal: " << std::hex << 127

            << "\n\t127 em decimal:     " << std::dec << 127 << "\n\n";

        127 em binario:     0001111111

        127 em octal:       0001111111

        127 em hexadecimal: 0001111111

        127 em decimal:     0001111111

Entao eu poderia fazer isso:

std::cout  << "\n\t127 em binario:     " << bin << 127

               << "\n\t127 em octal:       " << std::oct << 127

               << "\n\t127 em binario:     " << bin << 127

               << "\n\t127 em hexadecimal: " << std::hex << 127

               << "\n\t127 em binario:     " << bin << 127

               << "\n\t127 em decimal:     " << std::dec << 127

               << "\n\t127 em binario:     " << bin << 127 << "\n\n";*/

        127 em binario:     0001111111

        127 em octal:       177

        127 em binario:     0001111111

        127 em hexadecimal:  7f

        127 em decimal:     127

        127 em binario:      0001111111

wiki.anon

0 0

Quote

11. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

paulo1205
(usa Ubuntu)

Enviado em 15/12/2017 - 01:14h

dark777 escreveu:

Interessante porém estava pesquisando em outros forums e consegui chegar a este resultado

Minha resposta anterior foi no sentido de induzir você a uma solução. Ela, por si só, funcionava (embora eu tenha omitido especificamente a conversão para binário, em si), mas não a entreguei inteiramente pronta.

Você parece ter apanhado uma solução mais completa (mas também não tão completa) na Internet. Note que a ideia é semelhante à que eu lhe apresentei: um wrapper que captura o stream de saída ao qual é aplicado. A maior diferença entre o meu wrapper e o que você encontrou é que eu procuro devolver o stream original à expressão assim que possível (i.e. assim que um número fosse impresso), ao passo que o seu mantém o tipo de retorno como sendo o wrapper, mesmo que você imprima outros tipos de dados, e em várias operações sucessivas. Ele só restaura o stream envelopado à expressão quando você aplica um dos manipuladores da biblioteca padrão.

Ou não, porque, pelo que você falou, essa foi justamente a parte que deu erro.

Eu diria para você eliminar aquele “__cdecl”, principalmente se você não estiver usando Windows. E eu lamento que a Microsoft infeste seus sistemas com essas idiossincrasias de múltiplas convenções diferentes de passagem de argumento a funções, que é tão perniciosa que acaba vazando para os programas que nós fazemos, inclusive em algo que nem é tão complicado, como este caso que estamos analisando, ao lidar com um tipo de dados da própria biblioteca padrão (i.e. os ponteiros de função usados como tipo pelos manipuladores std::dec, std::hex e std::oct).

Alternativamente, você pode usar o preprocessador para tornar esse “__cdecl” (e seus congêneres) inócuo em sistemas não-Microsoft.

#if !defined(_WIN16) && !defined(_WIN32) && !defined(_WIN64)

#undef __cdecl

#undef __syscall

#undef __clrcall

#undef __thiscall

#undef __fastcall

#undef __vectorcall

// Que porre!

#define __cdecl

#define __syscall

#define __clrcall

#define __thiscall

#define __fastcall

#define __vectorcall

#endif

Com C++11, você pode fazer melhor ainda, e de um jeito que funcionará em qualquer sistema.

std::ostream &operator<<(decltype(std::dec) &_Pfn){

  /* bla, bla, bla */

}

1 0

Quote

12. Re: Sobrecarregando operator de saida c++[RESOLVIDO]

dark777
(usa Debian)

Enviado em 15/12/2017 - 03:59h

paulo1205 escreveu:

dark777 escreveu:

Interessante porém estava pesquisando em outros forums e consegui chegar a este resultado

#if !defined(_WIN16) && !defined(_WIN32) && !defined(_WIN64)

#undef __cdecl

#undef __syscall

#undef __clrcall

#undef __thiscall

#undef __fastcall

#undef __vectorcall

// Que porre!

#define __cdecl

#define __syscall

#define __clrcall

#define __thiscall

#define __fastcall

#define __vectorcall

#endif

Com C++11, você pode fazer melhor ainda, e de um jeito que funcionará em qualquer sistema.

std::ostream &operator<<(decltype(std::dec) &_Pfn){

  /* bla, bla, bla */

}

entendi dei uma pesquisada sobre esse __cdecl e nao tinha achado nada agora esta funcionando corretamente pois achei que era erro de sintaxe. modifiquei a parte do codigo adicionando sua sugestão e funcionou legal.. interessante...

wiki.anon

0 0

Quote