Ändern der Basisklasse in C++

Question

Ich habe ein Problem mit einigen geerbten Klassen und deren Basisklasse.

Zum Beispiel:

base class{ 

int x,y; // Doesnt really matter 
int counter; 

public: 

class(int x, int y):x(x), y(y), counter(1){} 

void add_counter(){counter++;} 
//stuff 
virtual ~base(){} 
} 



class1:public base{ 

public: 

class1():base(1,2){} 
} 

Jeder meiner geerbten Klassen (die ich ein paar haben) sie alle passieren die x, y voneinander verschieden. Und dann möchte ich diesen Zähler erhöhen, wenn ich ihn anrufe.

Das Problem, mit dem ich konfrontiert bin, ist, dass der Zähler NUR auf dieser Iteration erhöht. Kein Objekt wird neu erstellt (weil ich debuggte). Wenn ich den add_counter für die Klasse1 aufrufe, wird es von 1 auf 2 erhöht, aber wenn ich es noch einmal anrufe, wird es gleich sein (1 zu 2).

Was fehlt mir hier?

Vielen Dank.

Answer 1

Was fehlt mir hier?

Es scheint mir, dass Sie deren Typen gebaut Spur der Anzahl der Objekte behalten möchten von Base ableiten.

In diesem Fall müssen Sie counter eine static Membervariable machen, die Sie add_counter eine static Memberfunktion zu machen erfordert.

jedoch, die Sie benötigen, um:

1. Decrement die Zählung in dem destructor.
2. Fügen Sie einen Kopierkonstruktor in Base hinzu, um sicherzustellen, dass Objekte, die mit einem Kopierkonstruktor erstellt wurden, ebenfalls gezählt werden.

Hier ist eine vereinfachte Version von base zu tun, dass:

class base 
{ 
    public: 

    base() { inrement_counter(); } 

    base(base const& copy) { inrement_counter(); } 

    virtual ~base(){ decrement_counter(); } 

    private: 

    static int counter; 
    static void inrement_counter() {++counter;} 
    static void decrement_counter() {--counter;} 
} 

int base::counter = 0; 

---

Wenn Sie den Überblick über die Anzahl der derived1 Objekte konstruiert behalten möchten, werden Sie die Buchhaltung Code hinzufügen müssen, um derived1. Sie können eine Klassenvorlage erstellen, um diesen Prozess zu optimieren.

Beispiel:

template <typename T> 
struct ObjectCounter 
{ 
    ObjectCounter() { inrement_counter(); } 

    ObjectCounter(ObjectCounter const& copy) { inrement_counter(); } 

    virtual ~ObjectCounter(){ decrement_counter(); } 

    static int counter; 
    static void inrement_counter(){++counter;} 
    static void decrement_counter(){--counter;} 
}; 

template <typename T> 
int ObjectCounter<T>::counter = 0; 

class base 
{ 
}; 

class derived1 : public base, public ObjectCounter<derived1> 
{ 
}; 

class derived2 : public base, public ObjectCounter<derived2> 
{ 
}; 

#include <iostream> 

int main() 
{ 
    derived1 d1; 
    derived2 d2; 
    auto d3 = d2; 

    std::cout << d1.counter << std::endl; 
    std::cout << d2.counter << std::endl; 
} 

Ausgang:

1 
2