ho queste classi C++:variabili statiche a metodo statico in classe di base e l'eredità
class Base
{
protected:
static int method()
{
static int x = 0;
return x++;
}
};
class A : public Base
{
};
class B : public Base
{
};
disposta la variabile statica x essere condivisi tra A e B, o la volontà ognuno di loro ha un proprio x variabile indipendente (che è quello che voglio)?
Ci sarà solo un'istanza di x nell'intero programma. Un bel work-around è usare il CRTP:
template <class Derived>
class Base
{
protected:
static int method()
{
static int x = 0;
return x++;
}
};
class A : public Base<A> { };
class B : public Base<B> { };
Questo creerà un diverso Base<T>, e quindi un netto x, per ogni classe che ne deriva.
Potrebbe anche essere necessaria una base "Baser" per conservare il polimorfismo, come indicano Neil e Akanksh.
Ci sarà solo uno, condiviso da tutte e tre le classi. Se vuoi istanze separate, dovrai creare funzioni separate nelle classi derivate.
Il primo. Le variabili statiche locali sono legate al metodo che le contiene e method esiste in un'incarnazione per tutte le sottoclassi (infatti, per l'intera app, anche se il resto del programma non vede il metodo).
La variabile sarà condivisa - è per funzione - in questo caso la funzione a cui appartiene è Base::method(). Tuttavia se class Base era una classe template si otterrebbe un'istanza della variabile per ogni istanza (ogni set univoco di parametri template effettivi) del modello class Base - ogni istanza è una nuova funzione.
Se si sta facendo X come statico, verrà condiviso tra tutte le classi figlio. Nessun problema con la funzione che è statica.
Sono abbastanza sicuro che sarà condiviso tra A e B.
Se volete variabili indipendenti è possibile utilizzare il "modello Template Curiosamente ricorrente" come:
template<typename Derived>
class Base
{
protected:
static int method()
{
static int x = 0;
return x++;
}
};
class A : public Base<A>
{
};
class B : public Base<B>
{
};
Naturalmente, se si desidera il polimorfismo, si dovrà definire una classe anche "Baser", che deriva dalla Base, come Base<A> è diverso da come Base<B>:
class Baser
{
};
template<typename Derived>
class Base : public Baser
{
protected:
static int method()
{
static int x = 0;
return x++;
}
};
class A : public Base<A>
{};
class B : public Base<B>
{};
Ora anche A e B possono essere polimorfici.
Non è qualcosa che potresti controllare rapidamente con un compilatore e un codice di prova? –
@ttmrichter: non se si sospetta che possa dipendere dall'implementazione. E quando hai controllato che non lo è, hai trovato la risposta. –
@ttmrichter Avevo il sospetto che la variabile fosse condivisa, ma volevo anche vedere se qualcuno avesse un altro modo di risolvere il mio problema :) – Meh