Die Reduzierung der Verwendung globaler Variablen in C kann erreicht werden, wenn: 1. Verwendung von Kapselung und Singleton -Mustern, um Daten zu verbergen und Instanzen zu begrenzen; 2. Verwenden der Abh?ngigkeitsinjektion, um Abh?ngigkeiten zu bestehen; 3.. Verwenden lokaler statischer Variablen zum Ersetzen globaler gemeinsamer Daten; 4. Reduzieren Sie die Abh?ngigkeiten von globalen Variablen durch Namespace und modulare Organisation von Code.

Die Reduzierung der Verwendung globaler Variablen in C ist ein gro?artiges Thema, da globale Variablen h?ufig als Anti-Muster angesehen werden und den Code schwer zu pflegen und zu debuggen k?nnen. Die Reduzierung ihrer Verwendung ist jedoch nicht immer einfach, insbesondere wenn es um gro?e Projekte geht. Lassen Sie uns in dieses Thema eintauchen und sehen, wie dies in der Praxis erreicht werden kann.

Wenn wir in Betracht ziehen, globale Variablen zu reduzieren, ist die erste Frage, warum wir das tun? Das Problem mit globalen Variablen besteht darin, dass sie überall im Programm zugegriffen und ge?ndert werden k?nnen, was bedeutet, dass sie zu unvorhersehbarem Verhalten und schwer zu fehlenden Fehler führen k?nnen. Darüber hinaus erh?hen globale Variablen auch den Kopplungsgrad des Code, wodurch die Wiederverwendung von Code schwierig wird.

Wie kann man den Einsatz globaler Variablen in C reduzieren? Hier sind einige Strategien und Praktiken:

Paket- und Singleton -Modus

Wir k?nnen eine Kapselung verwenden, um Daten so zu verbergen, dass sie nur dort sichtbar sind, wo sie ben?tigt werden. Eine übliche Praxis ist die Verwendung von Singleton -Muster. Das Singleton -Muster kann Instanzen einer Klasse auf eine einschr?nken und damit die Verwendung globaler Variablen verringert.

 Klassenlogger {
Privat:
    statischer Logger* Instanz;
    Logger () {} // privater Konstruktor zur Verhinderung der direkten Instanziierung der ?ffentlichkeit:
    statischer Logger* getInstance () {
        if (! Instanz) {
            Instance = new Logger ();
        }
        Rückkehrinstanz;
    }

    void log (const std :: string & message) {
        std :: cout << message << std :: endl;
    }
};

Logger* logger :: instance = nullptr;

int main () {
    Logger :: getInstance ()-> log ("Dies ist eine Protokollnachricht");
    Rückkehr 0;
}

Dieses Beispiel zeigt, wie das Singleton -Muster anstelle von globalen Variablen verwendet wird. Die Logger -Klasse bietet eine global zug?ngliche Instanz über die GetInstance -Methode, wird jedoch weiterhin eingekapselt, wodurch direkten Zugriff auf globale Variablen vermieden werden.

Verwenden der Abh?ngigkeitsinjektion

Die Abh?ngigkeitsinjektion ist ein Entwurfsmuster, mit dem wir Abh?ngigkeiten an Objekte übergeben k?nnen, anstatt die Objekte diese Abh?ngigkeiten selbst zu erm?glichen. Dies hilft, die Abh?ngigkeit von globalen Variablen zu verringern.

 Klassendatenbank {
?ffentlich:
    void Connect () {
        std :: cout << "Verbindung zu Datenbank herstellen ..." << std :: endl;
    }
};

Klasse UserService {
Privat:
    Datenbank & db;

?ffentlich:
    UserService (Datenbank & Datenbank): DB (Datenbank) {}

    void Performoperation () {
        db.connect ();
        std :: cout << "Benutzeroperation ausführen ..." << std :: endl;
    }
};

int main () {
    Datenbank DB;
    UserService UserService (DB);
    UserService.performoperation ();
    Rückkehr 0;
}

In diesem Beispiel empf?ngt die UserService -Klasse eine Referenz auf ein Datenbankobjekt über den Konstruktor, anstatt direkt auf eine globale Datenbankinstanz zuzugreifen. Dies macht den Code modularer und prüfbarer.

Verwenden Sie lokale statische Variablen

Manchmal müssen wir einige Daten zwischen Funktionen teilen, aber wir k?nnen lokale statische Variablen anstelle von globalen Variablen verwenden. Lokale statische Variablen werden initialisiert, wenn die Funktion zum ersten Mal aufgerufen wird und ihren Wert w?hrend der gesamten Lebensdauer des Programms behalten, sie sind jedoch nur innerhalb der Funktion, die sie definiert, sichtbar.

 int getcounter () {
    statischer Int -Z?hler = 0;
    Rückgabeschalter;
}

int main () {
    std :: cout << getcounter () << std :: endl; // Ausgabe: 1
    std :: cout << getcounter () << std :: endl; // Ausgabe: 2
    Rückkehr 0;
}

Dieser Ansatz ist sehr nützlich, wenn Sie einen gemeinsam genutzten Z?hler oder eine ?hnliche Funktion ben?tigen, ohne globale Variablen verwenden zu müssen.

Namespaces und Modularit?t

Die Verwendung von Namespaces kann dazu beitragen, Ihren Code zu organisieren und die Abh?ngigkeit von globalen Variablen zu verringern. Durch die Gruppierung der damit verbundenen Funktionen in Namespaces k?nnen wir die Sichtbarkeit und Zug?nglichkeit unseres Codes besser verwalten.

 Namespace Utilities {
    int getRandomNumber () {
        ret Rand () zurück;
    }
}

int main () {
    std :: cout << Utilities :: GetRandomNumber () << std :: endl;
    Rückkehr 0;
}

In diesem Beispiel wird die GetRandomNumber -Funktion im Dienstprogramm -Namespace eher als globale Funktion existiert.

Vor- und Nachteile und Fallstricke

• Kapselung und Singleton -Muster : Der Vorteil besteht darin, dass die Verwendung globaler Variablen reduziert werden kann, und der Nachteil besteht darin, dass das Singleton -Muster einige andere Probleme einführen kann, z. Stellen Sie bei der Verwendung von Singleton -Muster sicher, dass es vernünftig verwendet wird und keine anderen Teile des Codes schwer zu verstehen oder aufrechtzuerhalten.

• Abh?ngigkeitsinjektion : Der Vorteil besteht darin, dass sie die Modularit?t und Testbarkeit des Codes verbessert, und der Nachteil besteht darin, dass er die Komplexit?t des Codes erh?hen kann, insbesondere wenn es sich um gro?e Mengen an Abh?ngigkeiten handelt. Bei Verwendung der Abh?ngigkeitsinjektion müssen Sie vorsichtig sein, um eine überm??ige Abh?ngigkeitsinjektion zu vermeiden und die Lesbarkeit und Wartbarkeit des Codes sicherzustellen.

• Lokale statische Variablen : Der Vorteil besteht darin, dass sie globale Variablen ersetzen k?nnen, und der Nachteil besteht darin, dass sie einige schwer verst?ndliche Nebenwirkungen verursachen k?nnen, insbesondere in Umgebungen mit mehreren Threaden. Stellen Sie bei der Verwendung lokaler statischer Variablen sicher, dass ihre Verwendung thread-safe ist.

• Namespace und Modularit?t : Der Vorteil besteht darin, dass er den Code besser organisieren und die Verwendung globaler Variablen verringern kann, und der Nachteil besteht darin, dass er die Komplexit?t des Codes erh?hen kann. Stellen Sie bei der Verwendung eines Namespace sicher, dass der Namespace vernünftig gestaltet ist und keine anderen Teile des Codes schwer zu verstehen oder zu warten.

In praktischen Anwendungen erfordert die Reduzierung der Verwendung globaler Variablen eine umfassende Berücksichtigung verschiedener Faktoren, einschlie?lich Code -Wartbarkeit, Testbarkeit und Leistung. Durch die rationale Anwendung der oben genannten Strategien k?nnen wir die Verwendung globaler Variablen erheblich reduzieren und so die Qualit?t und Zuverl?ssigkeit unseres Codes verbessern.

Kurz gesagt, die Reduzierung der Verwendung globaler Variablen ist ein Prozess, der kontinuierliche Praxis und Verbesserung erfordert. Durch Methoden wie Kapselung, Abh?ngigkeitsinjektion, lokale statische Variablen und Namespaces k?nnen wir unseren Code besser verwalten und potenzielle Probleme und Fehler reduzieren. Ich hoffe, diese Vorschl?ge helfen Ihnen dabei, sich besser mit globalen variablen Problemen in der C -Programmierung zu befassen.

Das obige ist der detaillierte Inhalt vonWie reduziere ich die Verwendung globaler Variablen in C?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!