C++ binario para decimal c++;

emanuelrichard · 7 de novembro de 2019

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;
}

Luís Roberto C. da Silva · 7 de novembro de 2019

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;
}

Ansi C · 7 de novembro de 2019

@emanuelrichard Bom Dia!

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

emanuelrichard · 7 de novembro de 2019

@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

Ansi C · 7 de novembro de 2019

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?

emanuelrichard · 7 de novembro de 2019

@Mauro Britivaldo Não sei como por números separados ...

Ansi C · 7 de novembro de 2019

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.

KXSY · 7 de novembro de 2019

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);
}

Ansi C · 7 de novembro de 2019

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.

arfneto · 8 de novembro de 2019

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

Luís Roberto C. da Silva · 8 de novembro de 2019

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

arfneto · 8 de novembro de 2019

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

Ansi C · 8 de novembro de 2019

@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.

Ansi C · 8 de novembro de 2019

***

Desculpas e obrigado.

arfneto · 9 de novembro de 2019

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

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

Ansi C · 9 de novembro de 2019

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:

Veja uma descrição na WikiPedia em portugues se não achar também muita informação.

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.

arfneto · 10 de novembro de 2019

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.

arfneto · 10 de novembro de 2019

Eis o endereço do tópico. Lá tem um link para um programa inteiro de exemplo

https://www.clubedohardware.com.br/forums/topic/1400061-sobrecarga-do-operador/?tab=comments#comment-7587030

arfneto · 12 de novembro de 2019

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

KXSY · 12 de novembro de 2019

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.