[C言語] グローバル変数を使わない方がいい理由を解説

#include <stdio.h>
int globalCounter = 0; // グローバル変数
void incrementCounter() {
    globalCounter++;
}
int main() {
    incrementCounter();
    printf("Counter: %d\n", globalCounter);
    return 0;
}

#include <stdio.h>
int errorFlag = 0; // グローバル変数
void checkError() {
    if (errorFlag) {
        printf("エラーが発生しました。\n");
    }
}
void setError() {
    errorFlag = 1; // 予期しない場所で変更
}
int main() {
    setError();
    checkError();
    return 0;
}

#include <stdio.h>
int sharedValue = 10; // グローバル変数
void modifyValue() {
    sharedValue += 5;
}
void resetValue() {
    sharedValue = 0; // 予期しないリセット
}
int main() {
    modifyValue();
    resetValue();
    printf("Shared Value: %d\n", sharedValue);
    return 0;
}

#include <stdio.h>
int largeArray[1000000]; // 大きなグローバル変数
int main() {
    largeArray[0] = 1;
    printf("First element: %d\n", largeArray[0]);
    return 0;
}

#include <stdio.h>
int sharedData = 0; // グローバル変数
void moduleA() {
    sharedData += 10;
}
void moduleB() {
    sharedData *= 2;
}
int main() {
    moduleA();
    moduleB();
    printf("Shared Data: %d\n", sharedData);
    return 0;
}

#include <stdio.h>
int testValue = 0; // グローバル変数
void incrementTestValue() {
    testValue++;
}
int main() {
    incrementTestValue();
    printf("Test Value: %d\n", testValue);
    return 0;
}

#include <stdio.h>
int configValue = 100; // グローバル変数
void updateConfig() {
    configValue = 200; // 変更
}
void printConfig() {
    printf("Config Value: %d\n", configValue);
}
int main() {
    updateConfig();
    printConfig();
    return 0;
}

#include <stdio.h>
// 引数と戻り値を利用してデータを管理
int add(int a, int b) {
    return a + b;
}
int main() {
    int result = add(5, 3);
    printf("Result: %d\n", result);
    return 0;
}

#include <stdio.h>
// 構造体を利用してデータを管理
typedef struct {
    int x;
    int y;
} Point;
void printPoint(Point p) {
    printf("Point: (%d, %d)\n", p.x, p.y);
}
int main() {
    Point p = {10, 20};
    printPoint(p);
    return 0;
}

#include <stdio.h>
// 静的変数を利用してデータを保持
void incrementCounter() {
    static int counter = 0; // 静的変数
    counter++;
    printf("Counter: %d\n", counter);
}
int main() {
    incrementCounter();
    incrementCounter();
    return 0;
}

#include <stdio.h>
// シングルトンパターンを利用したデータ管理
typedef struct {
    int value;
} Singleton;
Singleton* getInstance() {
    static Singleton instance = {0}; // 静的変数としてシングルトンを保持
    return &instance;
}
int main() {
    Singleton* s = getInstance();
    s->value = 42;
    printf("Singleton Value: %d\n", s->value);
    return 0;
}

#include <stdio.h>
// データを引数と戻り値で共有
int processData(int data) {
    return data * 2;
}
int main() {
    int input = 5;
    int result = processData(input);
    printf("Processed Data: %d\n", result);
    return 0;
}

#include <stdio.h>
// 状態を管理する構造体
typedef struct {
    int currentState;
} StateManager;
void updateState(StateManager* manager, int newState) {
    manager->currentState = newState;
}
void printState(const StateManager* manager) {
    printf("Current State: %d\n", manager->currentState);
}
int main() {
    StateManager manager = {0};
    updateState(&manager, 1);
    printState(&manager);
    return 0;
}

#include <stdio.h>
// 設定情報を管理する構造体
typedef struct {
    int settingA;
    int settingB;
} Config;
void applySettings(const Config* config) {
    printf("Setting A: %d, Setting B: %d\n", config->settingA, config->settingB);
}
int main() {
    Config config = {10, 20};
    applySettings(&config);
    return 0;
}

#include <stdio.h>
// モジュールごとにデータを管理
typedef struct {
    int moduleData;
} Module;
void processModule(Module* mod) {
    mod->moduleData += 10;
}
int main() {
    Module mod = {0};
    processModule(&mod);
    printf("Module Data: %d\n", mod.moduleData);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
// スレッドごとにデータを管理
typedef struct {
    int threadData;
} ThreadData;
void* threadFunction(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    data->threadData += 5;
    printf("Thread Data: %d\n", data->threadData);
    return NULL;
}
int main() {
    pthread_t thread;
    ThreadData data = {0};
    pthread_create(&thread, NULL, threadFunction, &data);
    pthread_join(thread, NULL);
    return 0;
}

#include <stdio.h>
// 組み込みシステムでのデータ管理
typedef struct {
    int sensorValue;
} SensorData;
void readSensor(SensorData* data) {
    data->sensorValue = 100; // センサーからの読み取り値を設定
}
int main() {
    SensorData sensor = {0};
    readSensor(&sensor);
    printf("Sensor Value: %d\n", sensor.sensorValue);
    return 0;
}