[C] Lettura caratteri dinamica

[k_mishima]

Purtroppo non riesco a capire cosa c'è che non va in questo prog, potreste correggermelo? Grazie.

Il problema lo da qui: memcpy(*a+n,b,sizeof(char))
WARNING: passing arg 2 of `memcpy' makes pointer from integer without a cast

Scrivere una function c che legge i singoli caratteri e crea la stringa
che li contiene usando allocazione dinamica e le funzioni memcpy(...) e memmove (...)

#include <stdio.h>
#include <stdlib.h>
#define N 50
void lettura_alloc_dinamica (char **a);
main()
{
      char *a;
      a=(char *)malloc(N*sizeof(char));
      lettura_alloc_dinamica(&a);
      printf("%s\n",a);
      free(a);
      system("pause");
      }
      
void lettura_alloc_dinamica (char **a)  
{    
     char b;
     short n=0;
     do
      {
      b=getchar();   
      memcpy(*a+n,b,sizeof(char));
      fflush(stdin);
      n+=1;
      }
      while (n!=N && b!=EOF);
      (*a)[n]=(char)NULL;
}

[cionci]

Hai sbagliato l'approccio...quello che ti si chiedeva era evidentemente eliminare l'allocazione preventiva di spazio...quindi devi ogni volta che c'è un nuovo carattere devi usare realloc per allargare lo spazio contenuto nella stringa di un carattere...e poi inserisci il carattere letto...
Non usare fflush(stdin) perché non ha un comportamento definito dallo standard...ed inoltre non serve...

Non è detto che, nonostante tu sia leggendo carattere per carattere, tu debba leggere soltanto il primo carattere per ogni volta che viene premuto l'invio in input (questo stai cercando di fare, visto l'uso di fflush)...invece puoi permettere in questo modo di tutti i caratteri immessi fino all'invio, facnedo appunto terminare la lettura di caratteri quando trovi '\n' e non EOF...

Tra l'altro per come hai scritto te il codice, è errato anche l'uso che fai del doppio puntatore...visto che il puntatore ad a non viene modificato dopo che viene passato alla funzione...

[k_mishima]

Originariamente inviato da cionci

Hai sbagliato l'approccio...quello che ti si chiedeva era evidentemente eliminare l'allocazione preventiva di spazio...quindi devi ogni volta che c'è un nuovo carattere devi usare realloc per allargare lo spazio contenuto nella stringa di un carattere...e poi inserisci il carattere letto...
Non usare fflush(stdin) perché non ha un comportamento definito dallo standard...ed inoltre non serve...

Ho usato realloc, ma è sbagliato mi sa, cosi' n vale 1 al primo realloc e dovrebbe valere 2, ma se inizializzo n a 1 all'inizio allora non va piu' bene l'istruzione a[n]=getchar(); perchè farebbe a[1]=getchar();

#include <stdio.h>
#include <stdlib.h>
void lettura_alloc_dinamica (char *a);
main()
{
      char *a;
      a=(char *)malloc(2*sizeof(char));
      puts("Digita i caratteri che compongono una parola");
      lettura_alloc_dinamica(a);
      puts("Parola intera");
      printf("%s\n",a);
      free(a);
      system("pause");
      }
      
void lettura_alloc_dinamica (char *a)  
{    
     short n=0;

     do
      {
      a[n]=getchar();
      n+=1;   
      a=(char *)realloc(a,n*sizeof(char));
      }
      while (a[n-1]!=EOF);
      a[n]='\0';
      }

Non è detto che, nonostante tu sia leggendo carattere per carattere, tu debba leggere soltanto il primo carattere per ogni volta che viene premuto l'invio in input (questo stai cercando di fare, visto l'uso di fflush)...invece puoi permettere in questo modo di tutti i caratteri immessi fino all'invio, facnedo appunto terminare la lettura di caratteri quando trovi '\n' e non EOF...

Mah, io sto litigando con ogni traccia di questi maledetti esercizi che devo fare per l'esame, sono tutte poco chiare, nel dubbio cmq lascerei 1 carattere per volta come ho fatto ora.

Originariamente inviato da cionci

Tra l'altro per come hai scritto te il codice, è errato anche l'uso che fai del doppio puntatore...visto che il puntatore ad a non viene modificato dopo che viene passato alla funzione...

Il passaggio di queste variabili dinamiche alla function non l'ho proprio capito perchè gli esercizi di esempio che ho sono tutti main, ma poi mi si richiedono le funcion senza averne mai vista 1 -.-
Ho copiazzato un po' il passaggio fatto in quell'altro esercizio sulla strcat.



Comunque l'output attuale è la stringa scritta tutta in colonna, cosi'

a
r
r
a
y


Non ho capito proprio perchè, sai come risolvere? grazie 1000 come sempre

[cionci]

Te ne trovi una su ogni riga perchè getchar legge anche \n...
Ritornerei al passaggio con il doppio puntatore perchè realloc potrebbe ritornare anche una locazione diversa da quella inziale.
Con la prima malloc alloca spazio per un solo carattere...

Attento che la realloc deve allocare n+1 caratteri: immaginati di essere alla prima iterazione con n = 0, in tal caso realloc allocherebbe un solo carattere (n = 1)...quindi all'iterazione stai accedendo sempre in overflow alla stringa (cioè nella cella successiva all'ultima allocata).

Inoltre se il ciclo finisce quando a[n-1]==EOF, EOF ti conviene toglierlo dal buffer, basta sovrascriverlo con \0
Quindi a[n-1]='\0' e non a[n]='\0'
A questo punto però ti resta un carattere in più allocato rispetto al numero di caratteri che hai, quindi evita di fare realloc se l'ultimo carattere letto è uguale a EOF.

[k_mishima]

E' venuto

#include <stdio.h>
#include <stdlib.h>
void lettura_alloc_dinamica (char *a);
main()
{
      char *a;
      a=(char *)malloc(2*sizeof(char));
      puts("Digita i caratteri che compongono una parola");
      lettura_alloc_dinamica(a);
      puts("Parola intera");
      printf("%s\n",a);
      free(a);
      system("pause");
      }
      
void lettura_alloc_dinamica (char *a)  
{    
     short n=0;

     do
      {
      a[n]=getchar();
      fflush(stdin);
      n+=1;   
      a=(char *)realloc(a,sizeof(char));
      }
      while (a[n-1]!=EOF);
      a[n-1]='\0';
      }

Col primo malloc avevo allocato 2 spazi, in modo che mi trovero' sempre 1 spazio in piu' da usare alla fine per lo \0

a=(char *)realloc(a,n*sizeof(char)); ho tolto la n perchè allocavo tantissimo spazio in piu' inutilmente vero? Ne basta solo 1 in piu' a ciclo.

Per togliere lo \n ho rimesso fflush(stdin), non so tu dici sempre che non è standard ma è l'unico modo che conosco per pulire il buffer.
Quindi a[n-1]='\0' e non a[n]='\0' corretto

Infine ho lasciato con 1 puntatore normale, mi spieghi perchè a volte se ne usano 2 (l'altro esercizio) e qui 1 solo?

[cionci]

a=(char *)realloc(a,sizeof(char));
E' errato...con realloc non devi tenere conto di quello che hai già allocato precedentemente...quindi serve n (anzi n+1 in questo caso)

Per il doppio puntatore:

void f(int **a)
{
    *a = (int *)malloc(sizeof(int));
}

...
int *a = NULL:
f(&a);
<-----qui a non punta più a NULL, ma punta allo spazio allocato con malloc

void f2(int *a)
{
    a = (int *)malloc(sizeof(int));
}

...
int *a = NULL:
f(a);
<-----qui a punta sempre a NULL

In sostanza si usa il doppio puntatore quando si prevede che l'indirizzo a cui punta il puntatore venga cambiato dalla funzione chiamata

In questo caso realloc potrebbe cambiare l'indirizzo puntato...

Per pulire il buffer puoi tranquillamente fare così:

int c;
do
{
   c = getchar();
}
while( c != '\n' && c != EOF);

fflush su stdin non si può fare perché lo standard prevede che si possa fare solo sui buffer di output...mentre il comportamento sui buffer di input non è specificato.

Per la prima allocazione non devi tenere conto di \0 in questo caso perché se anche leggessi un solo carattere seguito da EOF faresti comunque almeno una realloc che porterebbe la stringa a 2 caratteri

[k_mishima]

ok, allora ho sostituito con il doppio puntatore, ora l'esercizio è completo

grazie ancora, un altro esercizio è completo

[caramelleamare]

Salve, riapro questo vecchio post perché voglio fare qualcosa di simile. Mettiamo che abbia una stringa in input formata da N parole di M lettere. Vorrei creare un array dinamico che riallochi memoria per ogni diversa parola ogni volta che incontro uno spazio nella stringa, e allo stesso tempo voglio riallocare spazio dinamicamente per ogni singolo char che leggo.
Quindi alloco char per char, e quando scatta la parola alloco per quella parola, cioè zero spreco di spazio e nessun limite di inserimento.
Non mi è richiesto ma voglio capire bene come funzionano i puntatori a puntatori, malloc e la realloc.

Io ho immaginato un punt di punt con un doppio ciclo for: quello interno che rialloca i char e quello esterno le stringhe(parola), ma anche fosse giusta l'idea non riesco a scriverlo. Una guida?