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

[Carlos Adir]

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 **
    
    */
}

 

[Carlos Adir]

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

 

[Carlos Adir]

Obrigado! Como seria a maneira de fazer com C++? Agradeço desde já