Ir ao conteúdo
  • Cadastre-se
emanuelrichard

C++ binario para decimal c++;

Posts recomendados

preciso transforma binário em decimal mas não esta dando ...

#include <iostream>
#include <iomanip>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

using namespace std;

int main()
{
	char numero[10];
	int tam,valor;
	
	cout<<"Entre com numero pra converte para decimal : ";
	cin>>numero;
	
	tam = strlen(numero);
	
	for (int i = tam-1; i >= 0; i--) {
		if (numero[i] == '1') {
			valor += pow(2,tam-1-i);
		}
	}
	
	cout<<"Valor : "<<valor;
	
	
	return 0;
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Em 😄

#include <stdio.h>
#include <string.h>
#include <math.h>

int main(void){
  char bi[10];
  int i,tam,vlr;
  gets(bi);
  tam = strlen(bi)-1;
  for(i=0;i<=tam;i++){
    int num = bi[i]-'0'; //converte char em int
    vlr += num*(pow(2,(tam-i)));
  }
  printf("%d\n",vlr);
  return 0;
}

 

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@emanuelrichard Bom Dia!

Qual é o número máximo de bits ? O vetor indica 10.

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Mauro Britivaldo

Faça um programa que leia uma sequência de 8 bits e os converta para o número decimal equivalente.

Entrada

A entrada consiste de uma única linha com valores 0 ou 1, separados por um espaço em branco.

Saída

Na saída, o programa deve mostrar o número decimal correspondente à sequência dos bits na entrada

Exemplo de entrada    Exemplo de saída   

0 1 0 1 1 0 0 1                     89

Compartilhar este post


Link para o post
Compartilhar em outros sites

Então o número máximo é de 8 bits (1 byte). Agora preciso que você diga o que está acontecendo no programa. Ele para?

Compartilhar este post


Link para o post
Compartilhar em outros sites

 

7 horas atrás, emanuelrichard disse:

Não sei como por números separados

Para essa parte do exercício leia caractere por caractere que cin por padrão descarta os caracteres em branco no começo de cada leitura.

 

Para isso vai precisar de uma estrutura de repetição.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Não sei C++, mas eu acho que é assim.

#include <iostream>

using namespace std;

int main()
{
  int vetor[3];
  cin>>vetor[0]>>vetor[1]>>vetor[2];
  cout<<vetor[0]<<'|'<<vetor[1]<<'|'<<vetor[2];
  return(0);
}

Uma boa pergunta é. o que esse redirecionadores de conteúdo (">>" e "<<") são em C++? por que eu sei o que eles são em bash mas não faço a mínima ideia de como eles interagem com os objetos (fora que o objeto cin e cout parecem que vem do além).

 

Em C fica assim

#include <stdio.h>

int main()
{
  int vetor[3];
  scanf("%i %i %i",&vetor[0],&vetor[1],&vetor[2]);
  printf("%i|%i|%i",vetor[0],vetor[1],vetor[2]);
  return(0);
}

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
2 horas atrás, KXSY disse:

Uma boa pergunta é. o que esse redirecionadores de conteúdo (">>" e "<<") são em C++?

Só "atalhos" / sinalizadores.

 

Imagine que existam scanfs para vários tipos de dados padronizados no C. Em C++ isso é realidade para cin e mais.

 

A substituição ideal para cada tipo é automatizada assim não tem com que se preocupar. Pois o compilador vai encontrar a função certa naquele lugar do operador.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Tanto faz como vai multiplicar, o próprio compilador deve escolher a melhor maneira. pow,  << , vlr *2 ou vlr + vlr e não é o problema aqui

Mas pense em como está fazendo: Como a gente vê no ensino fundamental, a cada dígito mais pra esquerda o valor multiplica pela base. Seu programa não está multiplicando

 

Exemplos

 

Em decimal 127 = 1*10*10 + 2*10 + 7 * 1 = 127 

Em octal  127 =     1*8*8 +     1*8 + 7 * 1 = 73

Em binário 100 =   1*2*2 +     0*2 + 0*1 = 4


Acho que já entendeu: para qualquer base é a mesma coisa, e zero é o elemento neutro: 0 a esquerda não muda nada, zero a direita multiplica o valor pela base

 

Em decimal

1 vale 1
10 vale 1 * 10
100 vale 1 * 10 * 10
1000 vale 1 * 10 * 10 * 10
0100 vale 100

Então para qualquer base o loop é

    int valor = 0;
    int base = 2;
    int fator = 1;
    for (int i = strlen(vetor) - 1; i >= 0; i -= 1)
    {
        int digito = vetor[i] - '0';
        valor = valor + digito * fator;
        fator = fator * base;
    }

E funciona para qualquer base. Apenas para funcionar com outras bases  > 10 como hexadecimal por exemplo, precisa mudar a linha que calcula o valor do digito porque em hexa teria a=10, b=11, ... f=15. Usando um vetor de letras e um vetor de " pesos" daria pra escrever uma rotina genérica. Se der tempo depois posto um exemplo

Como exemplo desse loop, esse é o resultado

nesta maquina um int tem 4 bytes
entao o vetor tem que ter tamanho >= 32 posições
valor original=[0000000001000000000] com 19 digitos. base=2
valor em decimal = 512

Deste programa

#include "stdio.h"
#include "string.h"

int main(int argc, char* argv)
{
    char vetor[64];
    char* teste1 = "0000000001000000000"; // 9 zeros antes nove depois do um
    strcpy(vetor, teste1);
    int base = 2, valor = 0, fator = 1;
    printf("nesta maquina um int tem %d bytes\n", sizeof(int));
    printf("entao o vetor tem que ter tamanho >= %d posições\n", sizeof(int) * 8);
    printf("valor original=[%s] com %d digitos. base=%d\n",
        vetor, strlen(vetor), base);
    for (int i = strlen(vetor) - 1; i >= 0; i -= 1)
    {
        int digito = vetor[i] - '0';
        valor = valor + digito * fator;
        fator = fator * base;
    }
    printf("valor em decimal = %d\n", valor);
}

Note essas linhas

    printf("nesta maquina um int tem %d bytes\n", sizeof(int));
    printf("entao o vetor tem que ter tamanho >= %d posições\n", sizeof(int) * 8);

  onde o computador faz a gentileza de dizer o tamanho máximo do vetor a ser lido

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
21 horas atrás, Luís Roberto C. da Silva disse:

Em 😄


#include <stdio.h>
#include <string.h>
#include <math.h>

int main(void){
  char bi[10];
  int i,tam,vlr;
  gets(bi);
  tam = strlen(bi)-1;
  for(i=0;i<=tam;i++){
    int num = bi[i]-'0'; //converte char em int
    vlr += num*(pow(2,(tam-i)));
  }
  printf("%d\n",vlr);
  return 0;
}

 

O meu algoritmo funciona perfeitamente, é só traduzir pra C++ e para suas necessidades.

adicionado 1 minuto depois

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Voltando ao tema, essa função funciona da base 2 até a base 36, já que o sistema de numeração é igualzinho para qualquer base: a posição do dígito multiplicada pela correspondente potência da base, como vimos no ensino fundamental

int        valor_decimal_de(char* vetor, int base);

em um programa assim

int main(int argc, char* argv)
{
    valor_decimal_de("10000", 2);
    valor_decimal_de("100", 16);
    valor_decimal_de("FF", 16);
    valor_decimal_de("ffff", 16);
    valor_decimal_de("377", 8);

    valor_decimal_de("1b", 16);     // escape em hex
    valor_decimal_de("33", 8);      // escape em octal
    valor_decimal_de("027", 10);    // escape em decimal
    return 0;
}

Mostraria isso

valor original=[10000] com 5 digitos. base=2
valor em decimal de '10000' na base '2' = 16

valor original=[100] com 3 digitos. base=16
valor em decimal de '100' na base '16' = 256

valor original=[FF] com 2 digitos. base=16
valor em decimal de 'FF' na base '16' = 255

valor original=[ffff] com 4 digitos. base=16
valor em decimal de 'ffff' na base '16' = 65535

valor original=[377] com 3 digitos. base=8
valor em decimal de '377' na base '8' = 255

valor original=[1b] com 2 digitos. base=16
valor em decimal de '1b' na base '16' = 27

valor original=[33] com 2 digitos. base=8
valor em decimal de '33' na base '8' = 27

valor original=[027] com 3 digitos. base=10
valor em decimal de '027' na base '10' = 27

Um programa de teste

#include "stdio.h"
#include "string.h"

int        valor_decimal_de(char* vetor, int base)
{
    // para bases acima de 10 usamos as letras ate Z
    // entao limitamos o valor da base a 36, 10 digitos 
    // mas 26 letras
    long    valor = 0;
    long    fator = 1;
    long    digito;
    printf("\nvalor original=[%s] com %d digitos. base=%d\n",
        vetor, strlen(vetor), base);
    for (int i = strlen(vetor) - 1; i >= 0; i -= 1)
    {
        if ((vetor[i] >= '0') && (vetor[i] <= '9'))
            digito = vetor[i] - '0';
        else
            if ((vetor[i] >= 'a') && (vetor[i] <= 'z'))
                digito = vetor[i] - 'a' + 10;
            else
                if ((vetor[i] >= 'A') && (vetor[i] <= 'Z'))
                    digito = vetor[i] - 'A' + 10;
                else
                    return -1;
        valor = valor + digito * fator;
        fator = fator * base;
    }
    printf("valor em decimal de '%s' na base '%d' = %d\n",
        vetor, base, valor);
    return valor;
}

                                                       
int main(int argc, char* argv)
{
    valor_decimal_de("10000", 2);
    valor_decimal_de("100", 16);
    valor_decimal_de("FF", 16);
    valor_decimal_de("ffff", 16);
    valor_decimal_de("377", 8);

    valor_decimal_de("1b", 16);        // escape em hex
    valor_decimal_de("33", 8);        // escape em octal
    valor_decimal_de("027", 10);    // escape em decimal
    return 0;
}

 

adicionado 50 minutos depois

Em C++ main() muda pouco:

int main(int argc, char** argv)
{
    converte::valor_decimal_de("10000", 2);
    converte::valor_decimal_de("100", 16);
    converte::valor_decimal_de("FF", 16);
    converte::valor_decimal_de("ffff", 16);
    converte::valor_decimal_de("377", 8);

    converte::valor_decimal_de("1b", 16);        // escape em hex
    converte::valor_decimal_de("33", 8);        // escape em octal
    converte::valor_decimal_de("027", 10);    // escape em decimal
    return 0;
}

O resultado nada

valor original=[10000 com 5 digitos. base=2
valor em decimal de '10000' na base '2' = 16

valor original=[100 com 3 digitos. base=16
valor em decimal de '100' na base '16' = 256

valor original=[FF com 2 digitos. base=16
valor em decimal de 'FF' na base '16' = 255

valor original=[ffff com 4 digitos. base=16
valor em decimal de 'ffff' na base '16' = 65535

valor original=[377 com 3 digitos. base=8
valor em decimal de '377' na base '8' = 255

valor original=[1b com 2 digitos. base=16
valor em decimal de '1b' na base '16' = 27

valor original=[33 com 2 digitos. base=8
valor em decimal de '33' na base '8' = 27

valor original=[027 com 3 digitos. base=10
valor em decimal de '027' na base '10' = 27

E a função quase nada

class converte
{
public:
    converte() = delete;
    ~converte() = delete;

public:
    static int        valor_decimal_de(string vetor, int base)
    {
        // para bases acima de 10 usamos as letras ate Z
        // entao limitamos o valor da base a 36, 10 digitos 
        // mas 26 letras
        long    valor = 0;
        long    fator = 1;
        long    digito;
        int        l = vetor.size();
        cout << "\nvalor original=[" << vetor <<
            " com " << l << " digitos. base=" <<
            base << endl;
        for (int i = l - 1; i >= 0; i -= 1)
        {
            if ((vetor[i] >= '0') && (vetor[i] <= '9'))
                digito = vetor[i] - '0';
            else
                if ((vetor[i] >= 'a') && (vetor[i] <= 'z'))
                    digito = vetor[i] - 'a' + 10;
                else
                    if ((vetor[i] >= 'A') && (vetor[i] <= 'Z'))
                        digito = vetor[i] - 'A' + 10;
                    else
                        return -1;
            valor = valor + digito * fator;
            fator = fator * base;
        }
        cout << "valor em decimal de '" << vetor <<
            "' na base '" << base <<
            "' = " << valor << endl;
        return valor;
    }

};

É preciso envolver a função em uma classe e declarar como static afinal não faz sentido declarar uma variável da classe. Por isso mesmo o construtor deve ser invalidado com delete

 

Claro, há outras maneiras de escrever... Vou deixar cópias de programas de teste em cpp e c anexas se alguém precisar. 

programacpp.txt programac.txt

  • Curtir 1
  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@arfneto Por mais que seus programas façam a essa conversão que é bem simples, faz conversões entre outras bases (por exemplo hexadecimal). O assunto é decimal binário c++. Se não for pedir muito.

 

Você tem bastante experiência e boa vontade isso é muito louvável. Contudo, quem está só começando é muita informação posta de uma vez em código.

 


O programa abaixo não é nada especial, sua lógica é a mesma que outras e igual outros postagem d'aqui, a única diferença é na estrutura, nas repetições que não é em loop, mas pode ser acrescido loop sem prejuízo nenhum.

#include <iostream>
void snibble (char s [5])
{
    std::cin >> s [0];
    std::cin >> s [1];
    std::cin >> s [2];
    std::cin >> s [3];
}
void sbyte (char s [9])
{
    snibble (s);
    snibble (s + 4);
}
int main (void)
{
    char b [9] = {"00000000"}; // 9x char
    sbyte (b);

    std::cout << b << std::endl;
    return 0;
}

No caso o loop FOR pode ser acrescido na função mais interna (deixo isso por sua conta) o programa vai ler seus bits se tudo der certo.

 

Editado.

Compartilhar este post


Link para o post
Compartilhar em outros sites

***

Desculpas e obrigado.

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 08/11/2019 às 10:53, Mauro Britivaldo disse:

Por mais que seu algoritmo faça essa conversão simples, faz conversões entre outras bases (hex). O Tema é decimal binário c++

 

Não é o caso e não é o meu algoritmo.

E nada tem a ver com hex.

Como está no texto e nos exemplos a função funciona para qualquer base. Os exemplos estão em octal, binário, hexadecimal e decimal como pode ver. Claro que não há razão em converter decimal para decimal :D 

Mas funciona só até base 36 porque é só um exemplo e eu não queria ficar inventando símbolos além das letras e dígitos.

 

Origem

Essa notação posicional para representar números se acredita tenha sido criada por matemáticos hindus entre o século 1 e o século 4, e por isso ficou conhecida como o sistema hindu-arábico. Veja uma descrição na WikiPedia em portugues se não achar também muita informação.

 

A grande sacada deles em relação ao então tradicional sistema romano foi a criação do zero. Então você tinha uma série de símbolos --- algarismos --- que representava quantidades e ao esgotar os algarismos colocava um desses algarismos, o zero --- hoje conhecido como elemento neutro --- e começava de um novamente. Familiar não é? Conta até 9 aí acabam os números e você usa 10. Conta até 19 e aí usa 20. Conta até 99 e... 100

 

Assim sendo em qualquer base o valor do número é dado pela posição do algarismo da direita para a esquerda, multiplicando o valor do algarismo pela potência correspondente à posição dele. Acho que você intuitivamente sabe dessa característica posicional porque em parte de seu programa escreveu

int nibble (char s [5])
{
    int dec = 0;
    if (s [0] == '1') dec = dec + 8; //2^3
    if (s [1] == '1') dec = dec + 4; //2^2
    if (s [2] == '1') dec = dec + 2; //2^1
    if (s [3] == '1') dec = dec + 1; //2^0
    return dec;
}

Em termos bem legíveis é isso:

            valor = valor + digito * fator;
            fator = fator * base;
Em 08/11/2019 às 10:53, Mauro Britivaldo disse:

Contudo, quem está só começando é muita informação posta de uma vez

 

Não é. Nem é minha opinião.

Citação

Não há informação nova no que eu disse a respeito desse algoritmo desde talvez o início da era cristã

.

E esse algoritmo faz parte do ensino fundamental de matemática. Nem do ensino superior. 

Mesmo assim a tendência pelo que eu vi nos trechos de códigos aqui foi ignorar a questão posicional e usar exponenciação :) por isso insisti no caso.

 

Meu roteiro tradicional: 

  • Mostrei a razão de fazer assim --- crédito aos matemáticos hindus do início da era cristã.
  • Escrevi uma função em C que implementa esse milenar algoritmo
  • acrescentei uma função em C++ porque antes eu não tinha percebido que o tópico se referia a C++ e estou acostumado a ver programas em C aqui postados como C++. Mostrei a maneira tradicional de escrever isso em C++ que é o que se encontra em todo lugar que usa C++ e não costumo ver aqui no forum
  • acrescentei um programa completo em C, cujo resultado e detalhes eu já havia mostrado.
  • acrescentei um programa completo em C++, cujo resultado e detalhes eu já havia mostrado.

E estou de volta aqui acrescentando mais referências, para que outros que venham a ler isso possam talvez ter uma ideia da origem disso tudo: sistemas de numeração posicional e uma rotina de conversão em C e C++ com exemplos

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
3 horas atrás, arfneto disse:

Não é o caso e não é o meu algoritmo.

O algoritmo referido não é mesmo. Lamento não ser esclarecido é ter que escreve essa explicação tola quando apenas me referia aos programas.

 

3 horas atrás, arfneto disse:

Autores cuidadosos e conteúdo misto de variadas fontes bem escrito. Procuro principalmente para língua portuguesa. Mas isso não vem ao caso.

 

 

Caso é que o tema foi estendido para assuntos próximos que não o tema central quando claramente o autor se encontra em dificuldades no comecinho do seu programa.

 

Melhor ajudar quem respondendo suas (autor) perguntas do que fica discutindo o óbvio. Ainda assim toda ajuda é válida.

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 07/11/2019 às 18:51, KXSY disse:

Uma boa pergunta é. o que esse redirecionadores de conteúdo (">>" e "<<") são em C++? por que eu sei o que eles são em bash mas não faço a mínima ideia de como eles interagem com os objetos (fora que o objeto cin e cout parecem que vem do além)

@KXSY

 

Em C++ muitos operadores podem ser redefinidos em qualquer classe, para

  • implementar uma operação comum
  • aproveitar a representação a gosto do programador.

 

Para implementar uma operação comum

 

Imagine uma classe trem que tem uma ou mais locomotivas e pode ter zero ou mais vagões. Quando você declara 

Trem a;
Trem b;

Em C++ você pode redefinir o operador + por exemplo, para que você possa somar trens, e fazer com que a soma seja o esperado: some as locomotivas e os vagões no novo trem. E você possa escrever 

b = a + b; 

E seu Trem b passa a incluir locomotivas e vagões que estavam no Trem a, com o código que você determinou

É claro que antes de você redefinir + se você escrever b = a + b; seja lá o que acontecer não vai fazer sentido, certo? 

 

Para aproveitar a representação apenas

 

Você pode usar por exemplo em uma classe conjunto o operador ^ para a intersecção e o + para a união e assim por diante, porque fica fácil de ler e imaginar o que vai acontecer. Ou você pode usar para qualquer coisa

 

 

Os operadores >> e << em C++

 

Em C++ esses operadores são os mesmos de C : << é o left-bit-shift e >> é o contrário e fazem, como em C, deslocamento de bits para a esquerda ou direita

int c = 16 << 2;    // desloca 2 bits para a esquerda
                    // equivale a multiplicar por 4, 2*2

int d = 32 >> 4;    // desloca 4 bits para a direita
                    // equivale entao a dividir por 16 = 2*2*2**2 

vão deixar c = 64 e d = 2

 

Os operadores >> e << em streams em C++

 

Como já deve ter imaginado, esses operadores são redefinidos em C++ para as classes derivadas de stream, e são chamados de operadores de inserção. Não sei se é assim que ensinam em português, mas é o que aparece na documentação original. Veja em C++ << e C++ >> por exemplo

Por certo foram escolhidos pelo desenho, que lembra um fluxo indo na direção da saída e corresponde ao significado de stream. 

 

Em 07/11/2019 às 18:51, KXSY disse:

não faço a mínima ideia de como eles interagem com os objetos (fora que o objeto cin e cout parecem que vem do além)

 

Eles interagem conforme o desenho. Em std::istream dirigem os caracteres de stream para as variáveis como em 

cin >> valor;

Em std::ostream dirigem o fluxo de caracteres das variáveis para stream como em

cout << "coisas a mostrar" ;

E fica mais compacto que em C. 

 

Esses operadores vem do além?

 

Eles vem das mesmas entidades superiores que provem stdin, stdout e stderr em C. Você deve estar imaginando onde foi parar stderr. Simples: cerr pode ser usada em C++ com o mesmo propósito. Os projetistas de C++ usaram a possibilidade de redefinir os operadores --- overloading se diz na literatura --- porque gera programas mais compactos que usar funções como em C, fscanf(), fprintf() e tal.

 

Postei um exemplo outro dia usando uma estrutura de conjuntos que redefinia uns 10 operadores. Sei que é difícil achar essas coisas então postei esse aqui no forum. Não tenho o link agora. Depois eu vejo. Mas pode rapidamente pesquisar aqui.

 

Importante (na minha opinião)

  • Esses operadores são associativos à esquerda
  • Redefinir o operador << para uma classe é muito comum e é legal porque permite formatar uma saída do jeito que você quer e simplesmente escrever
  • cout << minhaClasse;

     

  • ao invés de escrever uma série de cout com cada campo da estrutura sempre que quiser mostrar os valores. Mais uma vez vou sugerir que veja o exemplo que postei.
  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 07/11/2019 às 10:46, emanuelrichard disse:

@Mauro Britivaldo

Faça um programa que leia uma sequência de 8 bits e os converta para o número decimal equivalente.

Entrada

A entrada consiste de uma única linha com valores 0 ou 1, separados por um espaço em branco.

Saída

Na saída, o programa deve mostrar o número decimal correspondente à sequência dos bits na entrada

Exemplo de entrada    Exemplo de saída   

0 1 0 1 1 0 0 1                     89

 

@emanuelrichard

 

:) Considerando esse enunciado bem objetivo e que eu não tinha lido...

 

Imagino que o instrutor esperava ver algo assim:

VALOR       0    1    0    1    1    0    0    1

bit         7    6    5    4    3    2    1    0

decimal   128   64   32   16    8    4    2    1

                64 +      16 +  8 +            1 = 89

E então mostraria isso

0 1 0 1 1 0 0 1
89

Esse programa minimalista em C++

#include <iostream>
int main(int argc, char** argv)
{
    int b7, b6, b5, b4, b3, b2, b1, b0;
    std::cin >> b7 >> b6 >> b5 >> b4 >> b3 >> b2 >> b1 >> b0;
    b0 = (b7<<7) + (b6<<6) + (b5<<5) + (b4<<4) + (b3<<3) + (b2<<2) + (b1<<1) + b0;
    std::cout << b0 << std::endl;
    return 0;
}

Ou este em C

#include "stdio.h"
int main(int argc, char** argv){
    int b7, b6, b5, b4, b3, b2, b1, b0;
    scanf("%d %d %d %d %d %d %d %d", &b7, &b6, &b5, &b4, &b3, &b2, &b1, &b0);
    b0 = (b7 << 7) + (b6 << 6) + (b5 << 5) + (b4 << 4) + (b3 << 3) + (b2 << 2) + (b1 << 1) + b0;
    printf("%d\n", b0);
}

Usando as variáveis com os nomes óbvios das posições dos bits e os operadores de deslocamento dos bits para colocar os valores nas posições corretas. E então somando.

 

Veja que em C++ justamente esses operadores << e >> foram redefinidos para a classe stream como operadores de inserção, e isso dá ao programa em C++ um aspecto curioso para dizer o mínimo. Os mesmos operadores em cin e cout tem outro uso

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

vou dar uma olhada mais tarde.

Em 10/11/2019 às 15:16, arfneto disse:

Em C++ muitos operadores podem ser redefinidos em qualquer classe, para

  • implementar uma operação comum
  • aproveitar a representação a gosto do programador.

Eu já conhecia sobrecarga (eu acho que a tradução e essa "Overloading"), mas só em objetos e funções (não estou me referindo a C++) já tinha visto pessoas usando esse tipo de técnica em delphi.

mas eu nunca tinha usado por causa do problema de tipagem fraca que produz assim como acontece com o #define em C.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...