Utilização correta de ponteiros.

[silentvictor 0]

Bem, comecei a estudar ponteiros, deeeesde o inico mesmo. Depois de ver algumas coisas eu fiz esse programa para ver se tinha aprendido de fato. Só que fiquei receioso sobre estar utilizando eles de forma correta.

E tambem queria tirar uma duvida, e se eu quisesse transformar a variavel nome em um ponteiro tambem? Como que ficaria todo o processo? Meu professor falou que poderia fazer o seguinte:

Criava a variavel

char buffer[Tamanho consideravel]

printf("Digite o nome: \n");
scanf("%s",buffer);
PTRnome = (char*)malloc(strlen(buffer)*(sizeof(char)));
strcpy(PTRnome,buffer);

O fato de que vou declarar um vetor de tamanho (exemplo: 1000), ja não vai quebrar o desempenho do programa?

#include <stdlib.h>
#include <stdio.h>



int main(){

   struct processo{
       char nome[20];        //Define estrutura processo.
       int prioridade;
   }processo;

   struct processo *Processo;

   Processo = (struct processo*)malloc((sizeof(struct processo))); //Alocação de memória para o ponteiro.
   printf("Nome processo: \n");
   scanf("%s",Processo->nome); //Recebe valor para o ponteiro.
   printf("Prioridade: \n");
   scanf("%i",&Processo->prioridade); //Recebe valor para o ponteiro.

   printf("Dados digitados:\n");
   printf("Nome: %s\n",Processo->nome); //Printa o valor do ponteiro.
   printf("Prioridade: %i\n",Processo->prioridade);//Printa o valor do ponteiro.
   printf("Endereço Nome: %p\n",&Processo->prioridade);
   printf("Endereço Prioridade: %p\n",&Processo->nome);

   return EXIT_SUCCESS;



}

Editado 5 de Novembro de 2013 por thoga31
GeSHi

[pwseo 223]

silentvictor,

O facto de alocares 1000 bytes para a variável buffer não tem impacto na performance do teu programa porque é uma alocação única na stack, e o tamanho não é nada de especial (~1KB).

Se quiseres de facto transformar o campo nome num apontador, terias que primeiro definir isso na tua struct:

struct processo {
 char *nome;
 int prioridade;
};

De seguida, terias que fazer essencialmente o que o teu professor referiu, mas com algumas alterações. Fica aqui um exemplo que facilmente poderás adaptar ao teu caso:

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

struct bla {
   char *nome;
};

int main(void) {
   size_t len;
   char buffer[512] = { 0, };
   struct bla s;

   /* todos os caracteres (max 511) até ao próximo <Enter> */
   scanf(" %511[^\n]", buffer);
   len = strlen(buffer);

   /* Alocar espaço para o nome lido.
    * Não precisamos de fazer cast do resultado (ou seja, nada de (char*)malloc(...)).
    * Não é preciso multiplicar por ‘sizeof(char)’ (que é SEMPRE 1).
    * Fazemos +1 porque é necessário termos espaço para o '\0' no final da string */
   s.nome = malloc(len + 1);
   /* Copiar o nome do buffer para a struct */
   strncpy(s.nome, buffer, len + 1);

   printf("nome: '%s'\n", s.nome);

   /* Temos que libertar a memória alocada */
   free(s.nome);

   return 0;
}

Posto isto, tens vários erros no teu código:

• Ao declarares struct processo { ... } processo estás também a criar uma variável processo (é para isso que serve escrever o nome após os { }):
  

  /* Fazer isto: */
  struct processo {
   ...
  } processo;
  
  /* é precisamente o mesmo que: */
  struct processo {
   ...
  };
  struct processo processo; /* criando assim uma variável ‘processo’ */

  
  

• Não estás a libertar a memória alocada (tens que usar a free() para isso...)
  
• Estás a fazer cast da malloc, que em C é um erro (só em C++ é que é necessário):
  

  /* Isto está mal: */
  Processo = (struct processo*)malloc((sizeof(struct processo)));
  
  /* O correcto é assim: */
  Processo = malloc(sizeof(struct processo));
  /* ou até melhor ainda: */
  Processo = malloc(sizeof *Processo);
  

  
  

Penso que é tudo

[silentvictor 0]

Cara, muiiito obrigado

Ajudou bastante, agora vou estudar mais um pouco até ter um melhor controle disso e testar outras coisas que meu professor disse... tipo ponteiros de ponteiros .-.

Mais uma vez, obrigado.

[HappyHippyHippo 1159]

bastaria perceber o que é um ponteiro para perceber o que um ponteiro para X, seja X um ponteiro ou uma saco de batatas

[silentvictor 0]

Fiz as alterações que disse e testei o programa... Quando chegou a hora de digitar a prioridade eu digitei valores até ver se aparecia algum erro com numeros grandes... Dai cheguei ao numero "12345678901" que tem 11 digitos e faz o programa exibir um numero totalmente diferente deste, o que acontece nesse caso? Falta de alocação de memória?

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

int main(){

int num,i;
char buffer[200];
size_t len;
struct processo1{
 char *nome;  //Define estrutura processo.
 int prioridade;
};
struct processo1 *processo;

processo = malloc(sizeof *processo); //Alocação de memória para o ponteiro.


printf("Nome processo: \n");
scanf("%199[^\n]",buffer); //Recebe valor para o ponteiro.
len = strlen(buffer);
processo->nome = malloc(len+1);
strncpy(processo->nome,buffer,len+1);
printf("Prioridade: \n");
scanf("%i",&processo->prioridade); //Recebe valor para o ponteiro.
printf("Dados digitados:\n");
printf("Nome: %s\n",processo->nome); //Printa o valor do ponteiro.
printf("Prioridade: %i\n",processo->prioridade);//Printa o valor do ponteiro.
printf("Endereço Nome: %p\n",&processo->prioridade);
printf("Endereço Prioridade: %p\n",&processo->nome);
free(processo->nome);
return EXIT_SUCCESS;
}

[HappyHippyHippo 1159]

responde a estas duas questões:

- quantos bytes tem um int

- qual maior valor que um int consegue guardar

[silentvictor 0]

4 bytes e é um numero bem menor do que eu coloquei. E por algum motivo não lembrei dos limites numéricos de um tipo .-.