Newsgroup: it.comp.lang.c++
Titolo: help : Costruttori statici chiamati allo startup

avrei una domanda su un problema che non riesco a circumnavigare 
in modo pulito,
come si puň emulare la chiamata di un COSTRUTTORE STATICO ?
Chiarisco meglio : ho delle classi ibride con dati dinamici ed 
alcuni dati privati ma shared tra le istanze, quindi dichiarate 
static.
Ora coi dati triviali, ricorro ad una banale inizializzazione 
via definizione al di fuori della classe e contestuale assegnamento.
Per alcuni dati piů complessi avrei bisogno di eseguire uan 
chiamata ad una funzione statica dove si eseguono calcoli e 
operazioni meno immediate, ma non rimandando alla prima chiamata 
del primo costruttore siccome tali dati devono essere pronti e 
accessibili anche da fuori e prescindendo da ciascuna singola 
istanza costruita via costruttore.
Come potrei affrontare il problema ?
Grazie in anticipo per ogni suggerimento
ciao
Soviet-Mario

Specificando l'inizializzazione direttamente nel codice o avvolgendo il
tuo membro dato statico in una classe ad hoc il cui costruttore di
default compie l'inizializzazione da te richiesta.
struct A {
   static int i;
    static int f() { return 2; }
  struct B {
    int j;
    B() : j(3) {}
  };
  static B b;
};
int A::i = A::f();
A::B b;
Ciao,
Nicola

 default compie l'inizializzazione da te richiesta.
qui sono proprio in altissimo mare.
Allora io ho una classe parzialmente statica. Mi suggerisci di 
avvolgerla in una dinamica ? Se cosě fosse resterei comunque 
fregato dal doverne chiamare il costruttore di default NEL 
codice, e non prima di entrare nel codice visibile).
Per un motivo un po' lungo da dire l'inizializzazione dovrebbe 
essere ultimata prima ancora che il flusso del programma si 
renda visibile, un po' come accade nell'istanziazione dei dati 
statici reali.
In ogni caso nel frattempo mi ristudio meglio i due frammenti di 
codice che magari capisco meglio la dritta
grazie
ciao
Soviet-Mario


 codice, e non prima di entrare nel codice visibile).
No, ho scritto di avvolgere il membro dato statico in una classe
realizzata apposta per inizializzarlo, come nel mio esempio avviene per
il membro dato statico b.
Ciao,
Nicola

 compilatore bacato, perché non c'è logica in questo vincolo)
La logica c'e': la presenza di un membro const presuppone l'esistenza
di un costruttore, perche' e' l'unico modo per inizializzarlo.
Ciao,
Nicola

 ho scoperto che manco i membri const sono consentiti nell'aggregato
Non capisco a cosa tu ti riferisca. Potresti farmi un'esempio?
Ciao

 sembra un limite non ragionevole a differenza degli altri.
Secondo me il punto e' che essendo const e' meglio che l'inizializzazione
sia fatta dall'utente e non da un costruttore di default visto che il valore
non potra' piu' essere modificato.
Ciao

 non potra' piu' essere modificato.
No scusa, ho capito male.
Cmq faccio un'esempio per vedere se capisco cosa vuoi dire:
struct A {
 A(int y) {};
 const int x;
};
int main() {
 A a[1] = {1};
 return 0;
}
Ti lamenti dell'errore che ottieni in un caso come questo?
Se si, l'errore si anche se non inizializzi a[1] con le graffe perche' il
problema e' legato alla presenza di un const non inizializza a prescindere
dall'uso dell'inizializzazione aggregata.
Ciao

 accetti int no?
no invece, non occorre. Basta (sufficiente e necessario) il 
default copy-constructor implicito, generato dal compilatore, 
che consiste in una grezza memberwise copy. Non definire i 
costruttori è l'unica condizione che serve a fare in modo che 
faccia lui e copi i dati uno dietro l'altro. Se invece vede un 
costruttore, allora ti segnala errore (lo stai aggirando)
ciao
cccp++mario


 Ti lamenti dell'errore che ottieni in un caso come questo?
no ovviamente, lo scope non č globale
(inoltre seguiti a definire costruttori, non consentiti negli 
aggregati)
Mi lamento di questo :
struct AggregUno {
   static int A;
   const int B;
};
int AggregUno :: A = 3; // OKAY
int AggregUno :: B = 2; // OKAY
struct AggregDue {
   static int C;
   const int D;
};
.... NIENTE ! Mi rendo conto che avrei cannato io, ooops.
fa come non avessi detto niente : č sensato che non possano 
esserci delle const, poiché siccome devono comuqnue essere 
definite una volta nello scope globale (e quindi non solo 
inizializzate, ma proprio DEFINITE AND INIZIALIZZATE, 
l'eventuale assegnamento con la initializer list avrebbe l'esito 
di reinizializzare piů volte una const, assurdo
vabbč, finalmente ho capito la ratio
ciao
cccp++marioi


 costruttore, allora ti segnala errore (lo stai aggirando)
Umh... non ti seguo bene. Cosa sto aggirando?
Se il costruttore da me definito fa tutte le copie che servono non ci sono
problemi.
Ciao

 .... NIENTE ! Mi rendo conto che avrei cannato io, ooops.
E che codice avresti voluto usare?
Ciao

 int AggregUno :: B = 2; // OKAY
Okay?
A me il compilatore dice che non e' possibile inizializzare il const in quel
modo in quanto non statico. Forse e' quello che tu avresti voluto fosse
possibile?
Ciao