Tamanho da string na definição;

[lesiano]

Boas; Esta é uma daquelas dúvidas q me aparece mais frequentemente;

Qd declaro um array de chars ñ faço puto de ideia do input q vou ter e ñ sei o tamanho. Normalmente meto uma carrada de '9's, mas é escusado. Reparem neste:

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

#define MAXWORD 1000;

int main(){
           char cadeiaDNA[100];
           int i;
           
           printf("Introduza a cadeia de DNA:\n");
           scanf("%s",&cadeiaDNA);
           
           for (i=0;cadeiaDNA[i]!='\0';i++){
                                            if (cadeiaDNA[i] == 'T'){
                                                                     cadeiaDNA[i] = 'A';
                                                                    }
                                           }
           
           printf("%s",cadeiaDNA);
           
           getch();
           
           }

i) Como viram defini uma MAXWORD. Ñ a consigo pôr dentro dos "[" "]" do array. Porquê?

ii) O código vai ser submetido a outro programa q lhe dará muitos inputs. Para contornar a eventualidade de ele receber uma string de maior tamanho q os tais 99 dos 100 chars definidos, o q posso fazer?

Obg.

[Baderous]

A directiva #define não leva ; (ponto e vírgula) no final.

Para o problema do input, podes optar por construir a string dinamicamente com o malloc.

[lesiano]

A directiva #define não leva ; (ponto e vírgula) no final.

Para o problema do input, podes optar por construir a string dinamicamente com o malloc.

Obg pela correcção, nd q eu ñ saiba, mas foi distracção pura. Daí ñ dar para pôr dentro do tamanho do array.

Neste caso em específico, podias dar-me um exemplo de como fazer isto com o malloc, sff? Obg.

(Já agr:)

char array[malloc(sizeof(scanf("%s",&array))]

Qq cosia assim? Ainda só estudei até funções. Listas ligadas e estruturas, tal como ficheiros, passam-me, por enquanto, ao lado.

[Rui Carlos]

Para o malloc:

int tamanho=150;
char *array=(char*)malloc(tamanho*sizeof(char));

[nata79]

penso que a ideia era leres do stdinput uma string cujo tamanho desconheces, para fazer isso penso que a única

alternativa seja leres caracter a caracter para uma lista ligada... pelo menos era assim que eu faria!

ps: LI2 

[fabiim]

Se tiveres a usar a libc:

int main()
{
char *buffer[1];
size_t to_read = 0; 
char *seq;
buffer[0] = NULL;

  getline(buffer,&to_read,stdin);
if (buffer[0] != NULL )
    seq = buffer[1];
else
  erro();
}

O código acima dá para ler linhas (acabadas em \n) de qualquer tamanho, a getline retorna 1 se não arranjar espaço para a sequência ou se encontrar

EOF (um carácter que indica o fim do ficheiro) (isto pode ser tricky se estiver a ler de um ficheiro de texto, que nao tem newline no fim);

A string final tem um '\n' nao te esqueças!.

Mais standard tens esta hipotese:

 
char *fgetseq(FILE *fp)
{
  char *seq; 
  char c; 
  int i;

/* 1 arranjamos espaco dinamicamente para um caracter */
  seq = (char *) malloc(sizeof(char));

  for (i=0, c = getc(fp) ; (c!= EOF) && (c!= '\n'); i++, c=getc(fp) )
      { 
  seq[i] = c;

       /* a realloc()  aumenta um espaco apontado por um ptr, 
          o espaco novo (maior ) pode estar num sitio diferente logo
          e preciso fazzer a atribuicao novamente */
seq = realloc(seq,sizeof(char)*(i+1));
if (seq == NULL) 
  return NULL;
      }
  
  seq[i] = '\0';
  
  return seq;

}

E já agora, eu tou a fazer o mesmo trabalho, julgo que a ideia seja só ler uma sequência de tamanho desconhecido apenas de um ficheiro, segundo o meu prof, o ficheiro apenas continha uma sequência, e podia-se resolver o problema com uma chamada á malloc, o tamanho era determinado sabendo apenas o tamanho do ficheiro. Depois era apanhar com um fgets, ou cena assim. Acho que c/ a getline ou a que apresentei acima temos uma solução menos limitada.

[Rui Carlos]

Estar constantemente a fazer um realloc para alocar mais 1 byte é capaz de não ser muito boa ideia...

[fabiim]

Estar constantemente a fazer um realloc para alocar mais 1 byte é capaz de não ser muito boa ideia...

porquê?

[Rui Carlos]

porquê?

Porque corres o risco de, de cada vez que lê um caracter, teres de copiar todos os caracteres já lidos para um nova localização. E se tiveres uma quantidade considerável de caracteres, isso terá consequências notórias no desempenho.

[TheDark]

No teu primeiro código, com char *buffer[1]; estás a declarar um array com uma posição, e com buffer[1] = NULL; a escrever na 2ª posição, lendo mais à frente dessa 2ª posição. Tens a certeza que o código funciona? não devias estar a ler de e escrever para buffer[0]?

[fabiim]

No teu primeiro código, com char *buffer[1]; estás a declarar um array com uma posição, e com buffer[1] = NULL; a escrever na 2ª posição, lendo mais à frente dessa 2ª posição. Tens a certeza que o código funciona? não devias estar a ler de e escrever para buffer[0]?

Tens razão, não funciona como estava. Já modifiquei.

Porque corres o risco de, de cada vez que lê um caracter, teres de copiar todos os caracteres já lidos para um nova localização. E se tiveres uma quantidade considerável de caracteres, isso terá consequências notórias no desempenho.

Pois, tb tens razão. Podia meter um ciclo e aumentar de 100 em 100 letras ou coisa parecida, e depois no final re-ajustar mas aí já não ia gostar muito da função. Haverá uma forma mais simples de resolver isso então ?

[Rui Carlos]

Pois, tb tens razão. Podia meter um ciclo e aumentar de 100 em 100 letras ou coisa parecida, e depois no final re-ajustar mas aí já não ia gostar muito da função. Haverá uma forma mais simples de resolver isso então ?

Aquilo que eu normalmente faço, é duplicar o tamanho do array, quando já não há posições disponíveis. É claro que acabam por ficar com muitas posições livres. Podes recorrer a soluções de compromisso, como aumentar o tamanho do array em 10%, por exemplo. O que acho essencial, é que o tamanho do novo espaço dependa do tamanho actual do array, de forma a que a função não tenha quebras significativas na eficiência caso haja muito caracteres para ler.

[lesiano]

Para o malloc:

int tamanho=150;
char *array=(char*)malloc(n*sizeof(char));

Acabei por ñ perceber o q é o "tamanho", se ñ está relacionado com o array.

Podes adaptar esse código ao meu, sff?

Eu depois pesquiso mais sobre esse assunto, mas agr realmente ñ estou a ver como o adaptar.

[Rui Carlos]

O tamanho é uma variável. Podes usar um scanf para colocar lá o valor que quiseres.

[TheDark]

A variável tamanho na declaração e a n no malloc devem ser a mesma.

[Rui Carlos]

A variável tamanho na declaração e a n no malloc devem ser a mesma.

Pois  ?

Nem tinha reparado nisso...

[lesiano]

Pois  ?

Nem tinha reparado nisso...

Daí eu ñ ter percebido o esquemático. 😉

[lesiano]

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


main(){
       char *p;
       int tamanho,i=1,t;
       
       p=(char *)malloc(tamanho*sizeof(char));
       
       if (!p){
        	   printf ("** Erro: Memoria Insuficiente **");
        	   exit;
               }
       
       for(i=0;(i<tamanho);i++){
                                scanf("%c",&p[i]);
                                }
       for(t=0;(t<i);t++){
                           putchar(p[t]);
                           }
       getch();
       }

Esta cena agr aloca dinamicamente. Mas... como fazer aqui o realloc para ele adicionar smp espaço alocado se surgirem mais de 10 caracteres? Obg.

[Rui Carlos]

Era capaz de ser melhor usares uma função que te lesse logo n caracteres de cada vez... No final, e metias a função dentro de um ciclo, que via se tinhas lido um '\n', e caso não tivesse acontecido, alocavas mais espaço e chamavas outra vez a função de leitura.

[lesiano]

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


main(){
       char *p;
       int tamanho=10,i,t=1,h;
       
       p=(char *)malloc(tamanho*sizeof(char));
       
       if (!p){
        	   printf ("** Erro: Memoria Insuficiente **");
        	   exit;
               }
       
       tamanho=10;
       
       for(i=0;(p[i-1]!='\n');i++){
                                   if(i==(tamanho-1)){
                                                      tamanho += tamanho;
                                                      p=(char*)realloc(p,tamanho*sizeof(char));
                                                      }        
                                   scanf("%c",&p[i]);
                                   }
       for(t=0;(t<i);t++){
                           putchar(p[t]);
                           }
       getch();
       }

Acabei por descobrir.  😁

Mts tentativas, mas quem corre por gosto ñ cansa. Assim, está bom em termos de desempenho? Há alternativas mais fiáveis?

Obg.