1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

C array strings

Discussão em 'Programação' iniciada por zebaril, 30 de Setembro de 2008. (Respostas: 20; Visualizações: 16219)

  1. zebaril

    zebaril Power Member

    Pessoal tou aqui na net ..mas tou com problemas en criar um array de strings em C..

    Alguém pode dar a dica..

    eu sei que consigo definir uma string usando char * word

    Agora gostava de ter um array

    Tipo

    array[0] = "teste1"
    array[1] = "teste2"

    Obrigado..
     
  2. pedroeeic

    pedroeeic Power Member

    Tenta:

    char[] word;
     
  3. zebaril

    zebaril Power Member

    depois nao tenho que alocar..memoria??

    gostava se possivel ver algum code de exemplo
     
  4. pedroeeic

    pedroeeic Power Member

    Nao precisas de alocar...fazes o seguinte para aceder:

    word[0]='s';
    word[1]='w";

    O que nao sei é quanta memoria isso ocupa....
     
  5. zebaril

    zebaril Power Member

    Estamos a falar de C..certo?

    É que isso dá-me erro..

    para declarar uma string tenho que fazer char *palavra[10] = "fsafs"

    um array de strings deveria ser char **array...

    agora preciso de alocar memoria...
     
  6. pedroeeic

    pedroeeic Power Member

    Esquece...tava a pensar noutra coisa...
     
  7. pedroeeic

    pedroeeic Power Member

    Tenta...

    char *palavra[10][10]
     
  8. zebaril

    zebaril Power Member

    yah assim consigo..mas não existe nenhuma maneira de ser array[0] = "bla..:"
     
  9. Noobs

    ok zebaril,

    1º Não ligues ao resto do pessoal que tá tudo muito mal.

    2º O que tu queres faz-se assim (e quando digo assim digo mesmo ASSIM!):

    char *array[N];



    N é o número de strings que queres na array... se quiseres um número variável fala comigo depois, que ensino-te a fazer (é mais complicado, mas totalmente fazível).

    Depois já podes fazer:

    array[0] = "isto"
    array[1] = "aquilo"
    ...
    array[N-1] = "etc"

    Não te preocupes com memória porque como estás a trabalhar com ponteiros o C alloca-te o espaço sozinho quando (friza-se QUANDO) fazes array = "qualquer coisa";
    Pronto já está, acho que isto ajudou bastante mais, qualquer dúvida fala comigo, não hesites.

    Quanto ao resto do pessoal... Não vale apena virem para aqui dizer que isto não funciona e tal porque eu sei bem do que falo e para os que têm dúvidas, sou aluno do Instituto Superior do Técnico e estou no 3º ano... (BOLAS! sou mesmo bom).
     
    Última edição: 30 de Setembro de 2008
  10. Aparicio

    Aparicio /dev/mod
    Staff Member

    Em parte estás certo, mas acho que não estás totalmente correcto.

    Se fizesses char array[10][10]; podias usar 10 strings com até 10 caracteres sem precisar de mais nada:
    array[0] = "palavra1";
    array[0] = "palavra2";

    Como estás a fazer, char *array[10]; apenas crias 10 ponteiros para strings sem memória alocada, ou seja é um array de ponteiros.

    Terias de fazer depois, array[0] = malloc( 10 * sizeof(char) ); e por aí fora para alocar a memória, depois é que podes fazer array[0] = "palavra1";

    Tambés sou aluno do IST embora só tenha começado agora o 1º ano. :P

    EDIT:
    Afinal também estás certo no resto, fazendo array[0] = "palavra"; aloca automaticamente a memória.
    Para se utilizar outras formas de preencher o array como strcpy e etc é que já vai ser preciso alocar a memória com o malloc.

    De qualquer forma deixo o que já escrevi que não deixa de estar correcto.
     
    Última edição: 30 de Setembro de 2008
  11. char array[10][10] é uma matriz 10 por 10. O que o Fr33d disse tá certo. Se só queres por strings não precisas de usar mallocs para a alocares a memória. Nestes casos o C ja faz isso.
     
  12. Mr_Miguel

    Mr_Miguel Power Member

    Vamos lá analisar isto...

    Processo 1:

    Limitar o array e as strings a um tamanho fixo (abordagem do Aparicio) - o que ele escreveu está correcto - uma string de N caracteres (no máximo) é do tipo "char array[N]". Assim sendo, um array de M strings de tamanho máximo N será do tipo "char array[M][N]". Tecnicamente sim, é uma matriz de caracteres, mas não vai ser usada como matriz "pura". Esta abordagem não requer o uso do malloc()

    Processo 2:

    Limitar o array a um tamanho fixo, mas não impor à partida limite nas strings (abordagem do Fr33d) - "char* array[N]" é um array de N ponteiros para caracter. Um ponteiro para caracter pode ser tratado como uma string, mas sendo um ponteiro, para onde aponta? Não foi inicializado! É necessário um malloc para cada um dos N ponteiros, para que cada ponteiro aponte para uma zona de memória onde possamos ler/escrever.

    Houve aqui alguma confusão no que diz respeito a strings e ao uso do malloc. Espero ter sido claro.

    --Miguel Martins
     
  13. C? ou C++?... Acho que estão confusos...
     
  14. Mr_Miguel

    Mr_Miguel Power Member

    C. Nenhum post até agora mencionou sequer algo que seja exclusivo ao C++.
     
  15. Aparicio

    Aparicio /dev/mod
    Staff Member

    À primeira vista também pensei que isso estivesse errado mas depois de experimentar que ao fazer array[0] = "palavra"; aloca automaticamente memória ao ponteiro array, não sendo preciso usar o malloc.

    Código:
    char *array;
        
    array = "abcdefghi";
    é equivalente a fazer:

    Código:
    char *array;
        
    array = malloc( 10 );
    
    strpcy( array, "abcdefghi" );
    Para atribuir logo uma string basta utilizar a 1ª forma, mas para casos mais práticos onde a string não esteja definida no início já se terá que usar a 2ª o malloc.
     
  16. Mr_Miguel

    Mr_Miguel Power Member

    Cuidado que isso não é bem verdade. Sim, tu podes fazer:

    Código:
    char* array = "abcdefghi"
    Mas na realidade estás a meter o ponteiro a apontar para uma zona de memória constante. Só vais poder ler dessa zona de memória, mas não escrever - "abcdefghi" é do tipo "const char*", ou, mais correctamente, "const char [10]". Se, no entanto, ele quiser uma zona de memória que tenha o "abcdefghi" e onde se possa escrever, ele deverá usar o malloc():

    Código:
    char* a_minha_string = malloc(30 * sizeof(char)); //Para 30 caracteres no máximo
    strcpy(a_minha_string, "abcdefghi");
    
     
  17. Aparicio

    Aparicio /dev/mod
    Staff Member

    Então acrescento ao que tinha dito:
    Para atribuir logo uma string que não se vá alterar durante a execução basta utilizar a 1ª forma, mas para casos mais práticos onde a string não esteja definida no início ou se altera durante a execução já se terá que usar a 2ª o malloc.

    Portanto fico como estava antes desta thread que já me deu voltas e reviravoltas. :p
     
  18. Just a reply

    Ok desta vez já há bastante mais informação útil...

    Para quem ainda não percebeu eu sou um aficcionado do C... lol...

    O meu post original limitou-se simplesmente a responder ao que o zebaril queria e note-se que lhe disse que se quiser algo mais sofisticado, não hesite falar comigo que eu ensino-o a fazer mallocs para o bem e para o mal.

    Não vale apena estar já a chateá-lo com mallocs se ele nem sequer se sente confortável com ponteiros, não vale apena rebentarmos em Segmentation fault.....

    Enfim,
    cumps
     
  19. zebaril

    zebaril Power Member

    Pessoal obrigado pelas dicas..

    Eu fiz este pequeno code que funciona agora estou com problemas em meter na memoria ou seja meter num array..

    Código:
    printf("Ler file..\n");
    char *array[30];
    int i=0;
    char word[20];
           while( fscanf( fp, " %s", word) !=EOF )
            {        
        printf("%s\n",word);
        array[i] = word;
        i++;
        //Examine word here
             }
    
    fclose(fp);
    
    //Ver
    int j=0; 
    for (j=0;  j<20; j++)
    printf("%d %s\n",j,array[j]);

    Tenho um while para ler o ficheiro onde igualo duas variaveis.
    Quando faço o print dentro do while a variavel word aquilo imprime tudo bem..

    mas quando imprimo o array num ciclo ele aparece-me sempre o mesmo elemento como e que resolvo esta situação..
     
    Última edição: 1 de Outubro de 2008
  20. Aparicio

    Aparicio /dev/mod
    Staff Member

    Tu estás a atribuir o ponteiro do word ao array, portanto todos os índices do array vão apontar para o que foi guardado no word da última vez.

    Experimenta substituir array = word; por

    Código:
    array[i] = malloc( strlen(word) * sizeof(char) );
    strcpy( array[i], word );
     

Partilhar esta Página