Cakupan dalam C++

Entitas dalam C++ memiliki nama, yang dapat dideklarasikan dan/atau didefinisikan. Deklarasi adalah definisi, tetapi definisi belum tentu deklarasi. Definisi mengalokasikan memori untuk entitas bernama, tetapi deklarasi mungkin atau mungkin tidak mengalokasikan memori untuk entitas bernama. Wilayah deklaratif adalah bagian terbesar dari program di mana nama entitas (variabel) valid. Wilayah itu disebut ruang lingkup atau ruang lingkup potensial. Artikel ini menjelaskan pelingkupan dalam C++. Selanjutnya, pengetahuan dasar dalam C++ diperlukan untuk memahami artikel ini.

Isi Artikel

Wilayah dan Cakupan Deklaratif

Wilayah deklaratif adalah bagian terbesar dari teks program di mana nama entitas valid. Ini adalah wilayah di mana nama yang tidak memenuhi syarat dapat digunakan (dilihat) untuk merujuk ke entitas yang sama. Perhatikan program singkat berikut:

#include <iostream> 
using namespace std;

void fn()
    {
        int var = 3;
        if (1==1)
        {
            cout<<var<<'n';
        }
    }

int main()
{
    fn();
    return 0;
}

Fungsi fn() memiliki dua blok: blok dalam untuk kondisi if dan blok luar untuk badan fungsi. Pengidentifikasi, var, diperkenalkan dan terlihat di blok luar. Itu juga terlihat di blok bagian dalam, dengan pernyataan cout. Blok luar dan dalam keduanya merupakan ruang lingkup untuk nama, var.

Namun, nama, var, masih dapat digunakan untuk mendeklarasikan entitas yang berbeda seperti float di blok bagian dalam. Kode berikut menggambarkan hal ini:

#include <iostream> 
using namespace std;

void fn()
    {
        int var = 3;
        if (1==1)
        {
            float var = 7.5;
            cout<<var<<'n';
        }
    }

int main()
{
    fn();
    return 0;
}

Keluarannya adalah 7,5. Dalam hal ini, nama, var, tidak dapat lagi digunakan di blok dalam untuk merujuk ke bilangan bulat dari nilai 3, yang diperkenalkan (dideklarasikan) di blok luar. Blok dalam seperti itu disebut sebagai ruang lingkup potensial untuk entitas yang dideklarasikan di blok luar.

Catatan: Entitas dengan tipe yang sama, seperti blok luar, masih dapat dideklarasikan di blok dalam. Namun dalam hal ini yang valid pada inner block adalah deklarasi baru beserta artinya, sedangkan deklarasi lama dan artinya di luar inner block tetap berlaku pada outer block.

Deklarasi dengan nama yang sama di dalam blok dalam biasanya mengesampingkan deklarasi dengan nama yang sama di luar blok dalam tersebut. Blok bagian dalam dapat membuat sarang blok bagian dalam lainnya.

Lingkup Global

Ketika seorang programmer baru mulai mengetik file, itu adalah lingkup global. Program singkat berikut mengilustrasikan hal ini:

#include <iostream>
using namespace std;

float var = 9.4;

int main()
{
    cout <<var<<'n';
    cout <<::var<<'n';

    return 0;
}

Outputnya adalah:
9,4
9,4

Dalam hal ini, wilayah atau ruang lingkup deklaratif untuk var dimulai dari titik deklarasi untuk var, berlanjut ke bawah hingga akhir file (unit terjemahan).

Blok fungsi main() adalah lingkup yang berbeda; itu adalah lingkup bersarang untuk lingkup global. Untuk mengakses entitas lingkup global, dari lingkup yang berbeda, pengidentifikasi digunakan secara langsung atau didahului oleh operator resolusi lingkup, ::.

Catatan: Entitas, main(), juga dideklarasikan dalam lingkup global.

Lingkup Blok

Pernyataan if, while, do, for, atau switch masing-masing dapat mendefinisikan sebuah blok. Pernyataan seperti itu adalah pernyataan majemuk. Nama variabel yang dideklarasikan dalam sebuah blok memiliki ruang lingkup blok. Ruang lingkupnya dimulai pada titik deklarasi dan berakhir pada akhir bloknya. Program singkat berikut mengilustrasikan ini untuk variabel, ident:

#include <iostream> 
using namespace std;

int main()
{
    if (1==1)
        {
            /*some statements*/
            int ident = 5;
            cout<<ident<<'n';
            /*some statements*/
        }
    return 0;
}

Sebuah variabel, seperti ident, dideklarasikan pada lingkup blok adalah variabel lokal.

Variabel yang dideklarasikan di luar cakupan blok dan di atasnya dapat dilihat di header blok (misalnya, kondisi untuk blok if) dan juga di dalam blok. Program singkat berikut mengilustrasikan hal ini untuk variabel, identif:

#include <iostream>  
using namespace std;

int main()
{
    int identif = 8;
 
    if (identif == 8)
        {
            cout<<identif<<'n';
        }
    return 0;
}

Outputnya adalah 8. Ada dua cakupan blok di sini: blok untuk fungsi main() dan pernyataan if-compound bersarang. Blok bersarang adalah cakupan potensial dari blok fungsi main().

Deklarasi yang diperkenalkan dalam lingkup blok tidak dapat dilihat di luar blok. Program singkat berikut, yang tidak dikompilasi, menggambarkan hal ini dengan variabel, variab:

#include <iostream>  
using namespace std;

int main()
{
    if (1 == 1)
        {
            int variab = 15;
        }
    cout<<variab<<'n';    //error: accessed outside its scope.

    return 0;
}

Kompiler menghasilkan pesan error untuk variab.

Entitas yang diperkenalkan, dideklarasikan di header fungsi majemuk, tidak dapat dilihat di luar (di bawah) pernyataan majemuk. Kode for-loop berikut tidak akan dikompilasi, menghasilkan pesan error:

#include <iostream> 
using namespace std;

int main()
{
    for (int i=0; i<4; ++i)
        {
            cout<<i<<' ';
        }
    cout<<i<<' ';

    return 0;
}

Variabel iterasi, i, terlihat di dalam blok for-loop tetapi tidak di luar blok for-loop.

Lingkup Fungsi

Parameter fungsi terlihat di blok fungsi. Entitas yang dideklarasikan dalam blok fungsi dilihat dari titik deklarasi hingga akhir blok fungsi. Program singkat berikut mengilustrasikan hal ini:

#include <iostream>
#include <string>
using namespace std;

string fn(string str)
    {
        char stri[] = "bananas";
        /*other statements*/
        string totalStr = str + stri;
        return totalStr;
    }

int main()
{
    string totStr = fn("eating ");
    cout<<totStr<<'n';

    return 0;
}

Outputnya adalah:
makan pisang

Catatan: Entitas yang dideklarasikan di luar fungsi (di atasnya) dapat dilihat di daftar parameter fungsi dan juga di blok fungsi.

Label

Ruang lingkup label adalah fungsi di mana label itu muncul. Kode berikut menggambarkan hal ini:

#include <iostream>
using namespace std;

void fn()
    {
        goto labl;
        /*other statements*/
        labl: int inte = 2;
        cout<<inte<<'n';
    }

int main()
{
    fn();

    return 0;
}

Keluarannya adalah 2.

Lingkup Pencacahan

Pencacahan Tanpa Cakupan
Pertimbangkan blok if berikut:

if (1==1)
        {
            enum {a, b, c=b+2};
            cout<<a<<' '<<b<<' '<<c<<'n';
        }

Keluarannya adalah 0 1 3.

Baris pertama dalam blok adalah pencacah, a, b, dan c adalah pencacahnya. Ruang lingkup p
encacahan dimulai dari titik deklarasi sampai akhir blok penutup pencacahan.

Pernyataan berikut tidak akan dikompilasi karena titik deklarasi c adalah setelah a:

enum {a=c+2, b, c};

Segmen kode berikut tidak akan dikompilasi karena enumerator diakses setelah blok enumerasi terlampir:

if (1==1)
    {
        enum {a, b, c=b+2};
    }
cout<<a<<' '<<b<<' '<<c<<'n';  //error: out of scope

Pencacahan di atas disebut sebagai pencacahan tak tercakup, dan pencacahnya disebut pencacah tak tercakup. Ini karena ini hanya dimulai dengan kata cadangan, enum. Enumerasi yang dimulai dengan enum class atau enum struct digambarkan sebagai enumerasi tercakup. Pencacah mereka digambarkan sebagai pencacah tercakup.

Cakupan Enumerasi
Pernyataan berikut ini OK:

enum class nam {a, b, c=b+2};

Ini adalah contoh enumerasi tercakup. Nama kelasnya adalah nam. Di sini, ruang lingkup pencacah dimulai dari titik deklarasi hingga akhir definisi pencacahan, dan bukan akhir blok penutup pencacahan. Kode berikut tidak akan dikompilasi:

if (1==1)
    {
        enum class nam {a, b, c=b+2};
        cout<<a<<' '<<b<<' '<<c<<'n';   //error: out of scope for enum class or enum struct  
    }

Lingkup Kelas

Dengan pelingkupan normal, wilayah deklaratif dimulai dari suatu titik, kemudian berlanjut dan berhenti di titik yang berbeda. Ruang lingkup ada di satu wilayah kontinu. Dengan kelas, ruang lingkup entitas dapat berada di wilayah berbeda yang tidak digabungkan. Aturan untuk blok bersarang masih berlaku. Program berikut menggambarkan hal ini:

#include <iostream>
using namespace std;

//Base class
class Cla
    {
        private:
            int memP = 5;
        protected:
            int memPro = 9;
        public:
        void fn()
            {
                cout<<memP<<'n';
            }
    };

//Derived Class
class DerCla: public Cla
    {
        public:
        int derMem = memPro;
    };
int main()
{
    Cla obj;
    obj.fn();
    DerCla derObj;
    cout<<derObj.derMem<<'n';

    return 0;
}

Outputnya adalah:
5
9

Di kelas Cla, variabel memP, terlihat pada titik deklarasi. Setelah itu, bagian pendek dari “protected” dilewati, kemudian terlihat lagi di blok fungsi anggota kelas. Kelas turunan dilewati, lalu terlihat lagi di lingkup fungsi main() (blok).

Di kelas Cla, variabel memPro, terlihat pada titik deklarasi. Bagian dari fungsi publik fn() dilewati, kemudian terlihat di blok deskripsi kelas turunan. Itu terlihat lagi di fungsi main().

Operator Resolusi Lingkup Operator
resolusi lingkup dalam C++ adalah ::. Ini digunakan untuk mengakses anggota statis kelas. Program berikut menggambarkan hal ini:

#include <iostream>
using namespace std;

class Cla
    {
        public:
            static int const mem = 5;
        public:
            static void fn()
                {
                    cout<<mem<<'n';
                }
    };
int main()
{
    cout<<Cla::mem<<'n';
    Cla::fn();

    return 0;
}

Outputnya adalah:
5
5

Anggota statis terlihat di blok fungsi main(), diakses menggunakan operator resolusi lingkup.

Cakupan Parameter Template

Lingkup normal nama parameter template dimulai dari titik deklarasi hingga akhir bloknya, seperti pada kode berikut:

template<typename T, typename U>  struct Ages
    {
        T John = 11;
        U Peter  = 12.3;
        T Mary  = 13;
        U Joy   = 14.6;
    };

U dan T terlihat di dalam blok.

Untuk prototipe fungsi templat, cakupannya dimulai dari titik de
klarasi hingga akhir daftar parameter fungsi, seperti pada pernyataan berikut:

template<typename T, typename U> void func (T no, U cha, const char *str );

Namun, ketika datang ke deskripsi kelas (definisi), ruang lingkup juga dapat menjadi bagian yang berbeda seperti pada kode berikut:

#include <iostream>
using namespace std;

    template<class T, class U> class TheCla
        {
            public:
            T num;
            static U ch;

            void func (U cha, const char *str)
                {
                    cout << "There are " << num << " books worth " << cha << str << " in the store." << 'n';
                }
            static void fun (U ch)
                {
                    if (ch == 'a')
                        cout << "Official static member function" << 'n';
                }
        };

int main()
{
    TheCla<int, char> obj;
    obj.num = 12;
    obj.func('$', "500");

    return 0;
}

Penyembunyian Nama

Contoh penyembunyian nama terjadi ketika nama dari tipe objek yang sama dideklarasikan ulang dalam blok bersarang. Program berikut menggambarkan hal ini:

#include <iostream>
using namespace std;

void fn()
    {
        int var = 3;
        if (1==1)
            {
                int var = 4;
                cout<<var<<'n';
            }
        cout<<var<<'n';
    }

int main()
{
    fn();
    return 0;
}

Outputnya adalah:
4
3

Itu karena var di blok bersarang menyembunyikan var di blok luar.

Kemungkinan untuk Mengulang Deklarasi dalam Lingkup yang Sama

Inti dari deklarasi adalah di mana nama itu diperkenalkan (untuk pertama kalinya) dalam ruang lingkupnya.

Prototipe Fungsi
Entitas yang berbeda, bahkan dari tipe yang berbeda, biasanya tidak dapat dideklarasikan dalam lingkup yang sama. Namun, prototipe fungsi dapat dideklarasikan lebih dari satu kali dalam lingkup yang sama. Program berikut dengan dua prototipe fungsi dan definisi fungsi yang sesuai menggambarkan hal ini:

#include <iostream>
using namespace std;

void fn(int num);
void fn(int num);

void fn(int num)
    {
        cout<<num<<'n';
    }

int main()
{
    fn(5);

    return 0;
}

Program ini bekerja.

Fungsi kelebihan beban Fungsi
kelebihan beban adalah fungsi dengan nama yang sama tetapi tanda tangan fungsi berbeda. Sebagai pengecualian lain, fungsi kelebihan beban dengan nama yang sama dapat didefinisikan dalam lingkup yang sama. Program berikut menggambarkan hal ini:

#include <iostream>
using namespace std;

void fn(int num)
    {
        cout<<num<<'n';
    }

void fn(float no)
    {
        cout<<no<<'n';
    }

int main()
{
    fn(5);
    float flt = 8.7;
    fn(flt);
   
    return 0;
}

Outputnya adalah:
5
8.7

Fungsi kelebihan beban telah didefinisikan dalam lingkup global.

Lingkup Namespace

Lingkup Namespace layak mendapatkan artikelnya sendiri. Artikel tersebut telah ditulis untuk situs web ini, linuxhint.com. Cukup ketik kata pencarian “Namespace Scope” di kotak pencarian situs ini (halaman) dan klik OK, dan Anda akan mendapatkan artikelnya.

Cakupan dalam Porsi Berbeda

Kelas bukan satu-satunya skema di mana ruang lingkup dapat berada di bagian yang berbeda. Penentu teman, useran tertentu dari penentu tipe yang diuraikan, dan arahan useran adalah skema lain di mana ruang lingkupnya berada di tempat yang berbeda – untuk detailnya, lihat nanti.

Kesimpulan

Ruang lingkup adalah wilayah deklaratif. Wilayah deklaratif adalah bagian terbesar dari teks program di mana nama entitas valid. Itu dapat dibagi menjadi lebih dari satu bagian sesuai d
engan skema pemrograman tertentu, seperti blok bersarang. Bagian yang tidak memiliki titik deklarasi membentuk ruang lingkup potensial. Cakupan potensial mungkin atau mungkin tidak memiliki deklarasi.

Related Posts