Ir ao conteúdo
  • Cadastre-se

Atribuição e operação com registro - C


Carlos Adir

Posts recomendados

Boa noite. Sou novo no fórum e não sei ainda se tem esse tópico em algum lugar da internet, embora eu tenha pesquisado muito e não achado nenhuma resposta à minha dúvida.

A minha dúvida: Como faz para fazer atribuição de uma struct a outra? Por exemplo, tenho o código aqui:

 

typedef struct
{
  double real, imaginario;
} complexo;

int main()
{
	complexo a, b, c;
  	double x;
  	/* Primeiramente, quero que todos os valores de 
    b sejam iguais o de a
    Uma maneira de fazer isso é:
    b.real = a.real;
    b.imaginario = a.imaginario;
    
    Contudo, gostaria de fazer algo como:
    b = a;
    É possivel fazer isso? */
  	
  	/* Quero então que b receba somente a parte
    imaginaria do complexo a, isso é, a maneira
    que gostaria de fazer:
    b = imaginario(a);
    
    O que aconteceria seria simplesmente:
    b.real = 0;
    b.imaginario = a.imaginario; */
  
  	/* Outra coisa que gostaria de saber se é 
    possivel fazer, é comparar structs, isso é:
    if(b == a)
    	printf("Olha, os complexos sao iguais!\n");
    
    No caso essa comparação, corresponderia ao resultado:
    
    if(b.real == a.real && b.imaginario == a.imaginario)
    	printf("Olha, os complexos sao iguais!\n");
    
    Ou também
    if(compara(a, b))
    	printf("Olha, os complexos sao iguais!\n");
    */
    /* E outras operações basicas como multiplicação
    de complexos, se resumiria:
    c = a*b;
    
    Que resultaria em:
    c.real = a.real * b.real - a.imaginario * b.imaginario;
    c.imaginario = a.real*b.imaginario + b.real*a.imaginario;
    
    Uma vez que (a+bi)*(c+di) = (ac - bd)+i(ad+cb)
    
    Multiplicação por um inteiro ou float:
    a *= x;
    Resultaria em:
	a.real *= x;
    a.imaginario *= x;
    Soma:
    c = a + b;
    c.real = a.real + b.real;
    c.imaginario = a.imaginario+b.imaginario; */
  	/* Entre outras operações com isso, eu poderia
    fazer outras coisas, com vetores, datas e tudo
    mais que eu acharia necessário 
    Tal coisa poderia ficar dentro de uma biblioteca
    como "complexos.h" e ficar mais fácil de manipular
    e limpar o código, em relação a criar funcoes do tipo:
    void copia_complexos(complexo *a, complexo *b)
    {
    	a->real = b->real;
        a->imaginario = b->imaginario;
    }
    E na chamada de função, teria-se
    ************ Instrucoes *********
    b = a;
    ************* Outras Instrucoes **
    
    No lugar de
    ************ Instrucoes *********
    copia_complexos(&b, &a);
    ************* Outras Instrucoes **
    
    */
}

 

Link para o comentário
Compartilhar em outros sites

Ou bem copiando um a um os valores, ou usando a função :

void * memcpy ( void * destination, const void * source, size_t num );

 

 

Copiando um a um você pode criar uma função que receba por parâmetro 2 referencias, a estrutura a ser copiada e estrutura e a estrutura que albergará os dados. Mais fácil é falar a "origem" e destino, se quero copiar A em B eu digo que A é a origem(orig) e B o destino(dest). Bem... vamos ver como fica a declaração:

void copiar( complexo *orig, complexo *dest ){...}

Para copiar seria você fazer dentro da função um a um tipo:
dest->real = orig->real;
dest->imaginario = orig->imaginario;
Isso iria dentro da função. Strings deveriam ser copiados com strcpy.

 

invocar seria tão fácil como:
copiar ( &a, &b ); // Seria como dizer "copiar a em b", o 'a' é a origem e 'b' é o destino. lembre disso... devemos passar as direções de a e b, lembre que copiar espera direções( referencias ) ;).

 

Para copiar com memcpy é fazer algo como:
memcpy ( &b, &a, sizeof(complexo) );
 

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

typedef struct{
  double real, imaginario;
} complexo;

void copiar( complexo *orig, complexo *dest ){
    dest->real = orig->real;
    dest->imaginario = orig->imaginario;
}

void imprimir( complexo *orig ){
    printf("Real:%2.2lf Imaginario:%2.2lf\n", orig->real, orig->imaginario);
}

int main(){
    complexo a={10.1, 20.2}, b;//a tem valor b não(tem lixo).
    
    copiar ( &a, &b );  //Copiando a em B
    imprimir(&b);      //Mostrando o que tem em b agora
    
    //Outra forma
    a.real = 100.11;
    a.imaginario = 200.22;
    memcpy ( &b, &a, sizeof(complexo) ); //copiar a em b diretamente na memoria... Operação perigosa! Se errar no sizeof pode dar erro no seu programa.
    imprimir(&b);      //Mostrando o que tem em b novamente
    
    return 0;
}

Exemplo completo acima.

Em c++ você poderia sobrecarregar o operador = para fazer algo como a = b.

 



 

Link para o comentário
Compartilhar em outros sites

Certo, eu sabia dessas maneiras.  Tem um codigo abaixo exemplificando. Haveria como fazer os comandos: c = a * b; c = a + b; c = a - b; c = a/b; a == b ?

#include <stdio.h>

typedef struct
{
  double real, imaginario;
} complexo;

complexo conjulgado(complexo a)
{
    complexo c = a;
    c.imaginario = - c.imaginario;
    return c;
}
double modulo_quadrado_complexo(complexo a)
{
    return a.real*a.real + a.imaginario*a.imaginario;
}
complexo soma_complexo(complexo a, complexo b)
{
    complexo c;
    c.real = a.real + b.real;
    c.imaginario = a.imaginario + b.imaginario;
    return c;
}
complexo subtrai_complexo(complexo a, complexo b)
{
    complexo c;
    c.real = a.real - b.real;
    c.imaginario = a.imaginario - b.imaginario;
    return c;
}
complexo multiplica_complexo(complexo a, complexo b)
{
    complexo c;
    c.real = a.real*b.real - a.imaginario*b.imaginario;
    c.imaginario = a.real*b.imaginario + a.imaginario*b.real;
    return c;
}
complexo divide_complexo(complexo a, complexo b)
{
    complexo c;
    double x = modulo_quadrado_complexo(b);
    c = multiplica_complexo(a, conjulgado(b));
    c.real /=x;
    c.imaginario /=x;
    return c;
}
int compara_complexos(complexo a, complexo b)
{
    if(a.real != b.real)
        return 0;
    if(a.imaginario != b.imaginario)
        return 0;
    return 1;
}
double absoluto(double numero)
{
    return numero < 0 ? -numero : numero;
}
void imprime_complexo(complexo a, char identificador)
{
    printf("%c = %.2lf %c %.2lf*i\n", identificador, a.real, a.imaginario < 0 ? '-' : '+', absoluto(a.imaginario));
}
int main()
{
	complexo a, b, c;
  	a.real = 1;
    a.imaginario = 3;
    b.real = 7;
    b.imaginario = -1;
    c.real = 3;
    c.imaginario = 4;
    printf("No inicio\n");
    imprime_complexo(a, 'a');
    imprime_complexo(b, 'b');
    imprime_complexo(c, 'c');
    printf("\n");

    printf("Depois da soma:\n");
    c = soma_complexo(a, b); /* Quero colocar simplesmente c = a + b */
    imprime_complexo(c, 'c');
    printf("Depois da subtracao:\n");
    c = subtrai_complexo(a, b); /* Quero colocar simplesmente c = a - b */
    imprime_complexo(c, 'c');
    printf("Depois da multiplicacao:\n");
    c = multiplica_complexo(a, b); /* Quero colocar c = a * b; */
    imprime_complexo(c, 'c');
    printf("Depois da Divisao:\n");
    c = divide_complexo(a, b); /* Quero colocar simplesmente c = a / b */
    imprime_complexo(c, 'c');


    printf("\nVerificando os valores:\n");
    imprime_complexo(a, 'a');
    imprime_complexo(b, 'b');
    imprime_complexo(c, 'c');
    b = a;
    printf("Agora b = a\n");
    imprime_complexo(a, 'a');
    imprime_complexo(b, 'b');
    
    printf("\nFazendo as comparacoes:\n");
    imprime_complexo(a, 'a');
    imprime_complexo(b, 'b');
    if(compara_complexos(a, b)) /* Gostaria de fazer a == b */
        printf("a e b sao iguais!\n");
    else
        printf("a e b sao diferentes\n");
    printf("\n");
    b.real = 1;
    b.imaginario = 2;
    imprime_complexo(a, 'a');
    imprime_complexo(b, 'b');
    if(compara_complexos(a, b)) /* Gostaria de fazer a == b */
        printf("a e b sao iguais!\n");
    else
        printf("a e b sao diferentes\n");
    
    return 0;
}

A saida desse programa é:

Citação

No inicio
a = 1.00 + 3.00*i
b = 7.00 - 1.00*i
c = 3.00 + 4.00*i

 

Depois da soma:
c = 8.00 + 2.00*i
Depois da subtracao:
c = -6.00 + 4.00*i
Depois da multiplicacao:
c = 10.00 + 20.00*i
Depois da Divisao:
c = 0.08 + 0.44*i

 

Verificando os valores:
a = 1.00 + 3.00*i
b = 7.00 - 1.00*i
c = 0.08 + 0.44*i
Agora b = a
a = 1.00 + 3.00*i
b = 1.00 + 3.00*i

 

Fazendo as comparacoes:
a = 1.00 + 3.00*i
b = 1.00 + 3.00*i
a e b sao iguais!

 

a = 1.00 + 3.00*i
b = 1.00 + 2.00*i
a e b sao diferentes

 

Link para o comentário
Compartilhar em outros sites

  • mês depois...
Visitante
Este tópico está impedido de receber novas respostas.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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...