[C] memorizzare testo in una variabile char

[ascatem]

c'è un modo per memorizzare del testo in una variabile di tipo char??

cioè.. uno mi scrive tipo un 500 caratteri di testo o espressioni numeriche e lui li memorizza dentro una variabile..

se si, come??

un altra cosa... per fargli cercare qualcosa all' interno di quella variabile? o per leggerla carattere per carattere? come faccio?

sennò potrei farlo con un vettore di caratteri.. ma posso una volta contati i carsatteri utilizzati del vettore assegnarli una profondità pari al numero di caratteri??

(es: se il vettoree contiene 200 caratteri e lo avevo impostato che poteva contenerne massimo 500 posso assegnargli come valore mnassimo 200? o cancella i caratteri memorizzati?)

[Mods]

memorizzare una stringa in una sola variabile char è impossibile. Come hai detto te bisogna usare un array di char.

Per ridimensionare l'array dovresti fare una roba simile:

char a[500];
char* b;
int i;

gets(a);
b=(char*)malloc(sizeof(char)*strlen(a));

strcpy(b,a);

E così ti trovi l'array b di dimensione pari ai caratteri più '\0'

[ascatem]

ehm.. io vorrei che all' array con i caratteri memorizzati venissero cancellato tutti i caratteri vuoti e ridimesionarlo in modotale che abbia come ampiezza massima i caratteri occupati. senza nemmeno un carattere vuoto

forse lo hai fatto.. ma non ho capito.. al massimo mi spiegheresti cosa hai fatto?? cioè.. non conosco malloc.. ecc.

quello con * è un puntatore?

[anx721]

Ecco un esempio nel caso in cui consideri come caratteri vuoti i caratteri spazio e i caratteri di tabulazione; lo puoi personalizzare per escludere anche altri caratteri:

char a[500];
char* b;
int i, j;

//prendo la stringa da input
gets(a);

j = 0;
//compatto la stringa eliminando gli spazi
//e i caratteri di tabulazione
for(i = 0; *a; i++){
    if((a[i] != ' ') && (a[i] != '\t')){
         a[j] = a[i];
         j++;
    }
}
//alla fine del ciclo j rappresenta la lunghezza della stringa
//compattata; per chiudere la strina alla posizione j
//inserisco il carattere di fine stringa
a[j] = '\0';

//alloco un array di tante posizioni quanti sono
//i caratteri della stringa + 1 per il carattere di fine stringa 
b = (char *)malloc(sizeof(char ) * (j + 1));

//copio la stringa compattata in b
strcpy(b, a);

[I'mtheleader]

Allora prima di tutto non puoi usare una sola variabile char.. ogni carattere ha un determinato codice per identificarlo e che è di un byte(8 bit) ciò significa che ogni carattere memorizzato è un byte...

Una variabile di tipo char è fatta apposta per memorizzare un solo byte quindi un solo carattere..

I problemi quindi si dovrebbero presentare con le stringhe...

Il C mette a disposizione la possibilità di avere delle stringhe e il metodo più conosciuto sono gli array di caratteri...

A quanto ho letto tu non sai bene usare i puntatori quindi ti faccio una breve spiegazione

In C esistono fondamentalmente due tipi di variabili.. le variabili normali che usiamo per memorizzare dei valori e altri tipi di variabili che vengono chiamati puntatori...

Queste variabili a differenza di quelle normali non contengono un valore numerico ma un indirizzo della memoria...

facciamo un esempio:

int ciao=5; questa variabile è normale e contiene il valore 5

-----------------------------------------------------------------

int *p; dichiaro una variabile di puntatore a interi
p=&ciao; dico che p dovrà contenere l'indirizzo della memoria
in cui c'è la variabile ciao quindi dove c'è il valore 5

dopo che ho fatto un assegnamento del genere se andrò a
stampare la variabile puntatore in output verrà
mandato l'indirizzo, mentre se la stampo con un
asterisco davanti mi verrà mandato in output il valore
che punta:

esempio

-printf("l'indirizzo è %d",p);

verrà stampato l'indirizzo a cui punta il puntatore

-printf("il valore a cui punta è %d",*p);

verrà stampato il valore 5 che è contenuto nell'indirizzo di
memoria contenuto nel puntatore.. si dice che punta a quel valore

fai comunque delle prove per avere delle idee più chiare.. torniamo quindi alle stringhe...

queste non sono altro che caratteri messi in memoria in locazione successive...

per esempio se prendo in input la parola ciao con una normale funzione di input che può essere la gets o la scanf in memoria avrò una robe del genere

cassetto 200 = c
cassetto 201 = i
cassetto 202 = a
cassetto 203 = o

diciamo che realmente non è proprio così ma questo aiuta a capire... con 200,201.... ho indicato l'indirizzo dei cassetti cioè delle locazioni

quindi in memoria i caratteri delle stringhe vengono memorizzati successivamente...

quando dichiariamo un vettore di array tante locazioni quant'è grosso l'array (es.char vet[500] saranno 500 locazioni) vengono svuotate da valori vecchi che non servono più che saranno ora disponibili per memorizzare la stringa...

adesso passiamo alla funzione malloc....

con questa è possibile allocare(cioè liberare della memoria per renderla diponibile per altri dati.. come succedeva con i vettori) solo che qua il numero delle locazioni cioè in questo caso dei caratteri può essere cambiato in maniera dinamica: posso sempre tenere sotto controllo il numero delle locazioni che uso per la stringa e quindi aumentarle se non bastano ma quindi anche cancellarle se ce ne sono troppe(funzione realloc) cosa che non posso fare con gli array di caratteri...

malloc si usa così

p=(char *)malloc(50)


adesso ti spiego...

prima dell'uguale c'è p che è un puntatore e che memorizzerà il valore restituito dalla funzione...

se malloc parte ad allocare dalla locazione 200 e in questo caso arriva alla 250 la funzione restituirà 200 cioè dove inizia nel nostro caso la stringa

dopo l'uguale c'è (char *).. questa operazione comune in C è detta cast.. la funzione malloc restituisce un tipo void cioè di nessun tipo.. tocca a me quindi con quell'operazione detta cast convertire il void in char cioè portare da tipo indefinito a tipo carattere..

dopo ho messo la funzione che prende come argomento lo spazio da allocare, cioè nel nostro caso il numero di caratteri che la stringa dovrà occupare...

il tuo problema però era quello di cambiare il numero di caratteri in modo tale che se erano troppi liberasse quelli inutilizzati..

a sto punto ti spieherò un istruzione che è la sizeof e una funzione che è la realloc

la sizeof restituisce un tipo intero e prende come unico argomentoo un tipo di dato o un puntatore...

se io faccio sizeof(int) questo restituirà 4 perchè sugli attuali computer gli interi occupano 4 byte.. se provo con char avrò 1..

se provo con un puntatore tipo la stringa che avevamo sopra avremo 50 perche malloc ha allocato 50 cassetti...

adesso la realloc... questa serve per ridimensionare un area di memoria creata con malloc...

è così: s=realloc(p,25)

restiutisce una nuova area di memoria contenente il valore di p cioè della vecchia stringa ma con un numero di byte inferiore cioè passa dai vecchi 50 a 25...

quindi alla fine potrei fare così:

char *s,*p;

p=(char *)malloc(200);
printf("\nInserisci una stringa : %s");
gets(p);
s=realloc(p,100)

adesso abbiamo una nuova stringa che è come la vecchia ma occupa la metà.. è passata da 200 a 100....

spero quindi che tu abbia capito... non è complesso e provando un po riesce a fare anche di meglio... ciao ciao e buon lavoro!!

[anx721]

Io avevo czpito che volevi eliminare caratteri vuoti all'interno della stringa, per questo ti avevo dato quella soluzione, se intendevi solo ottimizzare la memoria in modo da occupare solo un numero di caratteri necessario per contenere la tua stringa va bene la soluzione di Mods come quella di I'mtheleader,

[ascatem]

#include <stdio.h>
main()
{
int *p;
int ciao=5;
p=&ciao;
printf("valore %d \n", *p);
printf("indirizzo di memoria %d", p);
getchar();
}

il mio primo programma coi puntatori!!!

vabbè.. spero solo che sia giusto

ecco.. adesso veniamo a noi

praticamente io devo fare un programmino che inserito il testo tutto quello che non è stato utilizzato da un vettore lo butta. da quanto ho capito coi puntatori e le funzioni malloc, ecc si può fare lo ho fatto ma mi da errore alla dichiarazione di p=/char *)malloc(200); come mai?? dov'è l'errore?

#include <stdio.h>
main()
{
char *s,*p;
p=(char *)malloc(200);
int x=0;
while((p=gets()) !='.') // fino a ke non inserisce il punto memorizza
//il testo nel puntatore
{
++x; //calcola il numero dei caratteri

}
s=realloc(p,x); // elimina lo spazio in +
// utilizzato adattandolo al n° di caratteri
printf("stringa ottimizzata %s \n", s);
getchar();
}

grazie!!!

[anx721]

Non ho capito se il tuo scopo è prendere in input tutta la stringa una volta sola e poi eliminare lo spazio in eccesso o se vuoi prendere dall'utente un carattere alla volta finchè l'utente non inserisce il punto. Se vuoi fare quest'ultima cosa:

#include <stdio.h>
#include <stdlib.h>
main()
{
    char *s,*p;
    //utilizza l'operatore sizeof
    p = (char *)malloc(200 * sizeof(char));
    int x = 0;
    // fino a ke non inserisce il punto memorizza il carattere
    //letto nella posizione x e incrementa x
    while((p[x] = (char)getchar()) !='.')
    {
        x++;
    }
    //Alla fine metto il carattere di fine stringa
    //al posto del punto
    p[x] = '\0';

    //x indica ora l'indice dell'ultima posizione
    //quindi il numero di caratteri è (x + 1)
    s = realloc(p, x + 1);
    printf("stringa ottimizzata %s \n", s);
    getchar();
}

[I'mtheleader]

non so se è stato un errore di battitura ma è p=(*char)malloc(200) comunque ti dà errore perche devi includere anche un altra libreria...

oltre a fare #include<stdio.h> devi anche includere la malloc

#include<malloc.h>

ora dovrebbe funzionare.. ciao ciao

p.s. il tuo primo programma con i puntatori è ok