Interrogazione su variabili membro statiche di una classe in C ++

Question

Mi dispiace se questa domanda sembra banale per molti qui.

In un codice C ++ c'è qualcosa come di seguito:

class Foo
{
public:
   static int bands;
   ...
   ...
private:
   ...
   ...

}//class definition ends

int Foo::bands; //Note: here its not initialized to any value!

1. Perché l'istruzione precedente è di nuovo necessaria quando una volta 'band' è dichiarata all'interno della classe come statica?

2. Inoltre una variabile statica può essere dichiarata come variabile membro privata in qualsiasi classe?

Answer 1

C ++ nota una distinzione tra dichiarando e definendo . bands è dichiarato all'interno della classe, ma non definito.

Un membro di dati non statico verrebbe definito quando si definisce un oggetto di quel tipo, ma poiché un membro statico non fa parte di un oggetto specifico, ha bisogno della sua propria definizione.

Answer 2

a) È necessario perché è così che viene progettata la lingua.

b) Le variabili statiche sono inizializzate dal loro costruttore predefinito o a zero per i tipi predefiniti.

c) Sì, possono essere (e di solito sono) privati.

Answer 3

Dai un'occhiata a questa domanda.

Answer 4

Ha a che fare con i file obj, come vengono utilizzati e come gli indirizzi di memoria per le variabili con ambito globale vengono alla fine scoperti attraverso il processo di collegamento. I file oggetto contengono gli indirizzi di tutti i dati e le funzioni globali definiti nel cpp corrispondente. Disporre un po 'di memoria in modo relativo per dire al liker dove in quel file si possono trovare queste variabili / funzioni globali. Quindi, ad esempio

function doFoo can be found 0 bytes from beginning of this file
int foo::bands can be found 12 bytes from beginning of this file
etc

È quasi più facile pensare se hai già fatto C in precedenza. In un mondo C puro faresti le cose in un senso di programmazione modulare più tradizionale. Il tuo modulo verrebbe definito con un'intestazione e un cpp. L'intestazione definirebbe un "pubblico" variabile come sotto, usando la parola chiave extern, quindi istanziandola nel cpp.

foo.h

extern int bands; 

foo.cpp

#include "foo.h"
int bands;

foo.obj:

int bands can be found 0 bytes from the beginning of this file

Il " extern " la parola chiave indica che questo nome è valido e il suo indirizzo verrà risolto al momento del collegamento. Tutti quelli che includevano " foo.h " e volevo usare le bande "quotate" la variabile globale ora poteva usarla. Al momento del collegamento, il linker avrebbe capito che esistevano bande nel foo.obj. Se hai dimenticato di inserire " int bands " in foo.obj, otterrai un errore del linker e dovrai risolverlo.

In C ++ usando statico in una dichiarazione di classe simile. Stai dicendo agli utenti che esiste questa cosa chiamata " foo :: bands " e dove vivrà verrà risolto al momento del collegamento. Più avanti, il linker vede che in foo.obj esiste foo :: bands e tutti i riferimenti a foo :: bands possono essere risolti.

Answer 5

La mia comprensione è che dovresti dichiarare Foo :: bands solo se hai pianificato di usarlo prima di creare un'istanza della tua classe. Fondamentalmente, quando si dichiara una statica in una classe C ++, esiste solo una copia di quella variabile per tutte le istanze di quella classe. Tuttavia, normalmente non è possibile accedere a Foo :: bands fino a quando non viene dichiarata un'istanza della classe.

Ad esempio:

Puntatori ai membri

#include <iostream>
using namespace std;

class X {
public:
  int a;
  void f(int b) {
    cout << "The value of b is "<< b << endl;
  }
};

int main() {

  // declare pointer to data member
  int X::*ptiptr = &X::a;

  // declare a pointer to member function
  void (X::* ptfptr) (int) = &X::f;

  // create an object of class type X
  X xobject;

  // initialize data member
  xobject.*ptiptr = 10;

  cout << "The value of a is " << xobject.*ptiptr << endl;

  // call member function
  (xobject.*ptfptr) (20);
}