Mengurangkan penggunaan pembolehubah global dalam C boleh dicapai dengan: 1. Menggunakan corak enkapsulasi dan singleton untuk menyembunyikan data dan membatasi keadaan; 2. Menggunakan suntikan ketergantungan untuk lulus kebergantungan; 3. Menggunakan pembolehubah statik tempatan untuk menggantikan data bersama global; 4. Mengurangkan kebergantungan pada pembolehubah global melalui ruang nama dan organisasi modular kod.

Mengurangkan penggunaan pembolehubah global dalam C adalah topik yang hebat, kerana pembolehubah global sering dilihat sebagai anti-corak dan boleh membuat kod sukar untuk mengekalkan dan debug. Walau bagaimanapun, mengurangkan penggunaannya tidak selalu mudah, terutamanya apabila berurusan dengan projek besar. Mari kita menyelam topik ini dan lihat bagaimana ini dapat dicapai dalam amalan.

Apabila kita mempertimbangkan untuk mengurangkan pembolehubah global, soalan pertama adalah mengapa kita melakukan ini? Masalah dengan pembolehubah global adalah bahawa mereka boleh diakses dan diubah suai di mana -mana dalam program ini, yang bermaksud mereka boleh membawa kepada tingkah laku yang tidak dapat diramalkan dan sukar untuk mengesan kesilapan. Di samping itu, pembolehubah global juga meningkatkan tahap gandingan kod, menjadikan penggunaan semula kod sukar.

Jadi, bagaimana untuk mengurangkan penggunaan pembolehubah global dalam C? Berikut adalah beberapa strategi dan amalan:

Mod pakej dan singleton

Kita boleh menggunakan enkapsulasi untuk menyembunyikan data supaya ia dapat dilihat hanya di mana ia diperlukan. Amalan biasa adalah menggunakan corak singleton. Corak singleton boleh mengehadkan contoh kelas kepada satu, dengan itu mengurangkan penggunaan pembolehubah global.

 Logger Kelas {
Swasta:
    Logger statik* Instance;
    Logger () {} // Pembina peribadi untuk mengelakkan instansiasi langsung awam:
    Logger statik* getInstance () {
        jika (! contoh) {
            contoh = logger baru ();
        }
        Contoh kembali;
    }

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

Logger* logger :: instance = nullptr;

int main () {
    Logger :: getInstance ()-> log ("Ini adalah mesej log");
    kembali 0;
}

Contoh ini menunjukkan cara menggunakan corak singleton dan bukannya pembolehubah global. Kelas Logger menyediakan contoh yang boleh diakses secara global melalui kaedah GetInstance, tetapi ia masih terkandung, mengelakkan akses langsung kepada pembolehubah global.

Menggunakan suntikan ketergantungan

Suntikan ketergantungan adalah corak reka bentuk yang membolehkan kita melepasi kebergantungan kepada objek dan bukannya membiarkan objek mendapatkan kebergantungan ini sendiri. Ini membantu mengurangkan pergantungan pada pembolehubah global.

 pangkalan data kelas {
awam:
    void connect () {
        std :: cout << "Menyambung ke pangkalan data ..." << std :: endl;
    }
};

Kelas Userservice {
Swasta:
    Pangkalan data & db;

awam:
    UserService (pangkalan data & pangkalan data): db (pangkalan data) {}

    kekosongan prestasi () {
        db.connect ();
        std :: cout << "Melaksanakan operasi pengguna ..." << std :: endl;
    }
};

int main () {
    Pangkalan data DB;
    UserService UserService (DB);
    userService.performOperation ();
    kembali 0;
}

Dalam contoh ini, kelas UserService menerima rujukan kepada objek pangkalan data melalui pembina, dan bukannya secara langsung mengakses contoh pangkalan data global. Ini menjadikan kod lebih modular dan boleh diuji.

Gunakan pembolehubah statik tempatan

Kadang -kadang kita perlu berkongsi beberapa data antara fungsi, tetapi kita boleh menggunakan pembolehubah statik tempatan dan bukannya pembolehubah global. Pembolehubah statik tempatan diasaskan apabila fungsi dipanggil untuk kali pertama dan mengekalkan nilai mereka sepanjang hayat program, tetapi mereka hanya dapat dilihat dalam fungsi yang mentakrifkannya.

 int getCounter () {
    statik int counter = 0;
    Kaunter kembali;
}

int main () {
    std :: cout << getCounter () << std :: endl; // output: 1
    std :: cout << getCounter () << std :: endl; // output: 2
    kembali 0;
}

Pendekatan ini sangat berguna apabila anda memerlukan kaunter bersama atau fungsi yang serupa tanpa perlu menggunakan pembolehubah global.

Ruang nama dan modulariti

Menggunakan ruang nama boleh membantu mengatur kod anda dan mengurangkan kebergantungan pada pembolehubah global. Dengan mengumpulkan fungsi berkaitan ke dalam ruang nama, kami dapat menguruskan penglihatan dan kebolehcapaian kod kami dengan lebih baik.

 utiliti ruang nama {
    int getRandomNumber () {
        kembali rand ();
    }
}

int main () {
    std :: cout << utiliti :: getRandomNumber () << std :: endl;
    kembali 0;
}

Dalam contoh ini, fungsi getRandomNumber dikemas dalam ruang nama utiliti, dan bukannya wujud sebagai fungsi global.

Analisis kebaikan dan keburukan dan perangkap

• Corak enkapsulasi dan singleton : Kelebihannya ialah penggunaan pembolehubah global dapat dikurangkan, dan kelemahannya adalah bahawa corak singleton dapat memperkenalkan beberapa masalah lain, seperti kesukaran dalam ujian dan sukar untuk menguruskan kitaran hidup suatu contoh. Apabila menggunakan corak singleton, pastikan ia digunakan secara munasabah dan tidak menyebabkan bahagian lain kod sukar difahami atau diselenggara.

• Suntikan Ketergantungan : Kelebihannya ialah meningkatkan modulariti dan kesesuaian kod, dan kelemahannya adalah bahawa ia dapat meningkatkan kerumitan kod, terutama ketika berurusan dengan jumlah kebergantungan yang besar. Apabila menggunakan suntikan ketergantungan, anda perlu berhati -hati untuk mengelakkan suntikan ketergantungan yang berlebihan dan memastikan kebolehbacaan dan penyelenggaraan kod.

• Pembolehubah statik tempatan : Kelebihannya ialah mereka dapat menggantikan pembolehubah global, dan kelemahannya adalah bahawa mereka boleh menyebabkan beberapa kesan sampingan yang sukar difahami, terutama dalam persekitaran berbilang threaded. Apabila menggunakan pembolehubah statik tempatan, pastikan penggunaannya adalah thread-safe.

• Ruang nama dan modulariti : Kelebihannya ialah ia dapat mengatur kod dengan lebih baik dan mengurangkan penggunaan pembolehubah global, dan kelemahannya adalah bahawa ia dapat meningkatkan kerumitan kod. Apabila menggunakan ruang nama, pastikan ruang nama direka dengan munasabah dan tidak membuat bahagian lain kod sukar difahami atau diselenggara.

Dalam aplikasi praktikal, mengurangkan penggunaan pembolehubah global memerlukan pertimbangan yang komprehensif terhadap pelbagai faktor, termasuk kebolehkerjaan kod, kesesuaian dan prestasi. Dengan menggunakan strategi di atas secara rasional, kami dapat mengurangkan penggunaan pembolehubah global dengan ketara, dengan itu meningkatkan kualiti dan kebolehpercayaan kod kami.

Singkatnya, mengurangkan penggunaan pembolehubah global adalah proses yang memerlukan amalan dan peningkatan yang berterusan. Melalui kaedah seperti enkapsulasi, suntikan pergantungan, pembolehubah statik tempatan dan ruang nama, kami dapat menguruskan kod kami dengan lebih baik dan mengurangkan masalah dan kesilapan yang berpotensi. Semoga cadangan ini membantu anda menangani masalah pembolehubah global dalam pengaturcaraan C.

Atas ialah kandungan terperinci Bagaimana untuk mengurangkan penggunaan pembolehubah global di C?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!