Quels sont les scénarios d'application du mot-clé static dans les fonctions C++ ?

Le mot-clé static en C++ peut être appliqué aux fonctions pour réaliser les scénarios suivants : définir des méthodes de classe privées ou protégées pour obtenir un accès intra-classe ou dérivé ; créer des fonctions globales afin que les fonctions soient accessibles n'importe où dans le programme ; -Fonctions sécurisées, garantissant une utilisation sûre dans des environnements simultanés.

Scénarios d'application de mots clés statiques de fonction C++

Le mot clé static est largement utilisé dans les déclarations de fonctions en C++, qui contrôle la portée et la durée de vie de la fonction. Certains principaux scénarios d'application sont répertoriés ci-dessous : static 关键字在 C++ 中广泛用于函数声明中，它控制函数作用域和生存期。下面列出一些主要的应用场景：

1. 定义私有或受保护的类方法

static 函数可以被声明为私有或受保护的，这意味着它们只能在该类内部访问或派生类中访问。这对于创建仅用于内部管理的实用程序函数很有用。

2. 创建全局函数

static 函数可以以全局作用域定义，这意味着它们可以在程序的任何地方访问。这对于创建库函数或实用程序函数非常有用。

3. 创建线程安全的函数

static

1. Définir des méthodes de classe privées ou protégées

static Les fonctions peuvent être déclarées comme privées ou protégées, ce qui signifie qu'elles ne peuvent accéder qu'au sein de la classe ou dans une classe dérivée. Ceci est utile pour créer des fonctions utilitaires utilisées uniquement pour l'administration interne.

2. Créer des fonctions globales

static Les fonctions peuvent être définies avec une portée globale, ce qui signifie qu'elles sont accessibles depuis n'importe où dans le programme. Ceci est utile pour créer des fonctions de bibliothèque ou des fonctions utilitaires.

3. Créez des fonctions thread-safe

static Les fonctions sont thread-safe, ce qui signifie qu'elles peuvent être utilisées en toute sécurité dans un environnement simultané. En effet, ils n'existent que sous forme d'une seule copie et ne sont pas modifiés par un accès simultané.

Cas pratique :

🎜🎜🎜Fonction statique privée : 🎜🎜

class MyClass {
public:
    void foo() {
        static int count = 0;  // 私有静态变量
        count++;
        std::cout << "Call count: " << count << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.foo();  // 输出：Call count: 1
    obj.foo();  // 输出：Call count: 2
    // count 变量只在 foo() 方法中可见，不能从主函数中访问。
}

🎜🎜Fonction statique protégée : 🎜🎜

class Base {
protected:
    static int value;  // 受保护静态变量
};

class Derived : public Base {
public:
    static void set_value(int v) {
        Base::value = v;  // 可以访问基类的受保护静态成员
    }

    static int get_value() {
        return Base::value;  // 可以访问基类的受保护静态成员
    }
};

int main() {
    Derived::set_value(100);
    std::cout << "Value: " << Derived::get_value() << std::endl;  // 输出：Value: 100
    // 只能通过 Derived 类访问 value 变量，因为它继承了 Base 类。
}

🎜🎜Fonction statique globale : 🎜🎜

static int global_count = 0;  // 全局静态变量

int increment_count() {
    return ++global_count;  // 返回并递增全局计数器
}

int main() {
    std::cout << increment_count() << std::endl;  // 输出：1
    std::cout << increment_count() << std::endl;  // 输出：2
    // 全局计数器在程序的整个生命周期中都可以访问。
}

🎜🎜Fonction statique thread-safe : 🎜🎜

class ThreadSafeClass {
public:
    static int get_random_number() {
        static std::random_device rd;  // 静态随机数生成器
        static std::mt19937 gen(rd());
        return gen();
    }
};

int main() {
    std::thread t1([] {
        for (int i = 0; i < 10000; i++) {
            ThreadSafeClass::get_random_number();
        }
    });

    std::thread t2([] {
        for (int i = 0; i < 10000; i++) {
            ThreadSafeClass::get_random_number();
        }
    });

    t1.join();
    t2.join();
    // 即使从多个线程并发访问，get_random_number 函数也能生成线程安全的随机数。
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!