Newsgroup: it.comp.lang.c++
Titolo: utilizzo typedef struct

Premetto che sono un principiante, devo dare l'esame di info1 a ing. info.
Il problema è che dichiaro una "typedef struct " all'inizio del programma.
All'interno delle funzioni dichiaro una variabile del nuovo tipo typedef;
se controllo il contenuto della variabile appena dichiarata contiene delle
schifezze,
tutta roba di "ììììììììì" mah... potrebbe starmi bene, però c'è un modo per
svuotare,
per inizializzare la nuova variabile con tutti i valori del typedef a null o
vuota insomma?
L'altra cosa strana è che invece dichiarando una variabile globale (quindi
subito dopo la dichiarazione del typedef) che utilizza quel typedef e testo
all'inizio del programma il contenuto della variabile,
questa è regolarmente vuota. Perchè non avviene lo stesso se la dichiaro
all'interno della
routine? E, comunque, avendola dichiarata a livello globale, ogni tanto
avrei la necessita di
reinizializzare la variabile, di essere sicuro che la variabile non abbia
dentro valori assegnati
durante l'esecuzione del programma.
Non so se sono stato chiaro ma il c++ su queste cose non è molto chiaro... o
sbaglio?
grazie 1000 x chi mi aiuterà
ciao
davide

ObiWanKenobi wrote:

dunque, premesso che in quest'e-mail si capisce poco o niente ti dico
questo: le variabili globali vengono inizializzate, le variabili locali
no. Per questo motivo, possono (anzi, stai certo che lo faranno) contenere
robaccia a caso. Inizializzarle è un concetto che dipende strettamente da
quello che devi fare e correlato al tipo della variabile da inizializzare.
Se per esempio un intero potrebbe essere 0, una stringa potrebbe essere ""
oppure "<empty>" o un valore nullo per il puntatore (se c'è un puntatore
di mezzo)... insomma, dipende dal contesto. 
Se ti serve sapere altro devi essere più preciso, però per inizializzare
un intero basta usare l'operatore di assegnamento, così come per le
stringhe C++, mentre usi le funzioni str(qualcosa) per le stringhe C.
Il C++ non sarà chiarissimo, ma se studiassi un po' di più...
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


ok.
allora il problema è di come inizializzare una stringa. es:
    typedef struct
    {    char codi[15];
          char cogn[40];
          char nome[40];
    }REC_UTENTE;
all'interno di una funzione dichiaro
    REC_UTENTE ut;
e adesso ut contiene schifezze
e poi inizializzo come? se riuscissi a fare
    strcpy( ut.codi[1], '' );
    strcpy( ut.codi[2], '' );
sarei contento
mi pare che dia errore.
scusate se sono un po' incasinato nello spiegare.
avendo esperienza su altri linguaggi sto cercando di entrarci
un po' dentro.
grazie di nuovo

 mi pare che dia errore.
se vuoi fare un carattere alla volta:
ut.codi[0]='T';
ut.codi[1]='o';
ut.codi[2]='m';
ut.codi[3]='m';
ut.codi[4]='y';
ut.codi[5]='\0';
se vuoi fare la stringa in una volta sola:
strncpy(ut.codi, "Tommy", 15 );
Per il secondo metodo ricordati di includere l'header cstring (o string.h se
il tuo non e' c++ standard).
Sei un tantino indietro con il C++ o sbaglio?!? (tra le altre cose questo e'
C piu' che C++ !!!)
Tommy

 strncpy(ut.codi, "Tommy", 15 );
se volevi fare in modo che la stringa non contenga nulla:
ut.codi[0]='\0';
e basta, non serve altro!
oppure ancora usando il secondo metodo che ti avevo dato:
strncpy(ut.codi,"",15);
Tommy

[snipped]
premetto che questo è un ng sul C++.
quindi non codare in C.
Le struct in C++ sono delle classi il cui modificatore di default è public:.
premesso questo, i typedef non ti servono.
struct FooBarUsefullStruct
{
    int foo;
    int bar;
};
è gia' un tipo.
come saprai in C++ esistono i costruttori per inizializzare.
USALI.
#include <iostream>
struct FooBarUsefullStruct
{
    int foo;
    int bar;
    FooBarUsefullStruct() : foo(1) , bar(2){}
    FooBarUsefullStruct(int givenfoo, int givenbar): foo(givenfoo),
bar(givenbar){ }
};
int main(int argc, char**argv)
{
    FooBarUsefullStruct myfoobar(6,6);
    FooBarUsefullStruct* myheapfoobar = new FooBarUsefullStruct();
    std::cout << "myfoobar.foo is " <<  myfoobar.foo << std::endl;
    std::cout << "myfoobar.bar is " <<  myfoobar.bar << std::endl;
    std::cout << "myheapfoobar->foo is " <<  myheapfoobar->foo << std::endl;
    std::cout << "myheapfoobar->bar is " <<  myheapfoobar->bar << std::endl;
    std::cout << std::endl;
    delete myheapfoobar;
    return 0;
}
//
myfoobar.foo is 6
myfoobar.bar is 6
myheapfoobar->foo is 1
myheapfoobar->bar is 2