Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
Carlos Adir

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

Recommended Posts

Carlos Adir    0

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

 

Editado por Carlos Adir

Compartilhar este post


Link para o post
Compartilhar em outros sites
vangodp    399

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.

 



 

Compartilhar este post


Link para o post
Compartilhar em outros sites
Carlos Adir    0
  • Autor do tópico
  • 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

     

    Editado por Carlos Adir
    Colocar as saidas

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
    vangodp    399
    6 horas atrás, Carlos Adir disse:

    Haveria como fazer os comandos: c = a * b; c = a + b; c = a - b; c = a/b; a == b ?

    Em c++ sim. Em C até onde sei não.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
    Carlos Adir    0
  • Autor do tópico
  • Obrigado! Como seria a maneira de fazer com C++? Agradeço desde já

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
    vangodp    399

    Usando o construtor de cópia. Explicar o que é um construtor de cópia acho que seria pouco producente pois praticamente você deveria saber programação orientada a objetos. você sabe programação orientada a objetos?

    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






    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

    ×