Tilgangsmodifikatorer - Access modifiers

Tilgangsmodifikatorer (eller tilgangsspesifikatorer ) er nøkkelord på objektorienterte språk som angir tilgjengeligheten til klasser, metoder og andre medlemmer. Tilgangsmodifikatorer er en spesifikk del av programmeringsspråksyntaks som brukes for å lette innkapsling av komponenter.

I C ++ er det bare tre tilgangsmodifikatorer. C # utvider antallet av dem til seks, mens Java har fire tilgangsmodifikatorer, men tre nøkkelord for dette formålet. I Java, som ikke har noe nøkkelord før, er standard pakken-privat modifikator.

Når klassen er erklært offentlig, er den tilgjengelig for andre klasser som er definert i samme pakke, så vel som de som er definert i andre pakker. Dette er den mest brukte spesifikatoren for klasser. Imidlertid kan en klasse i seg selv ikke erklæres som privat. Hvis ingen tilgangsspesifikatorer er oppgitt, vil standard tilgangsbegrensninger bli brukt. Klassen vil være tilgjengelig for andre klasser i samme pakke, men vil være utilgjengelig for klasser utenfor pakken. Når vi sier at en klasse er utilgjengelig, betyr det ganske enkelt at vi ikke kan lage et objekt av den klassen eller erklære en variabel av den klassetypen. Spesifikatoren for beskyttet tilgang kan ikke brukes på en klasse.

Navn på nøkkelord

C ++ bruker de tre modifikatorer kalt public , protected og private . C # har modifikatorer public , protected , internal , private , protected internal , og private protected . Java har public , package , protected , og private . Tilgangsmodifisereren package er standard og brukes, hvis det mangler et annet nøkkelord for tilgangsmodifikator. Betydningen av disse modifikatorene kan variere fra språk til språk. En sammenligning av nøkkelordene, bestilt fra de mest restriktive til de mest åpne, og deres betydning på disse tre språkene følger. Deres synlighet varierer fra samme klasse til pakken der klassen er definert til en generell tilgangstillatelse. Nedenfor er maksimal tilgang skrevet inn i tabellen.

I Swift er det fem forskjellige tilgangsnivåer i forhold til både kildefilen der enheten er definert og modulen som inneholder den kildefilen.

Eksempel i C ++

#include <iostream>
#include <conio.h>
using std::cout;
using std::endl;

struct B { // default access modifier inside struct is public
    void set_n(int v) { n = v; }
    void f()          { cout << "B::f" << endl; }
  protected:
    int m, n; // B::m, B::n are protected
  private:
    int x;
};
 
struct D : B {
    using B::m;               // D::m is public
    int get_n() { return n; } // B::n is accessible here, but not outside
//  int get_x() { return x; } // ERROR, B::x is inaccessible here
 private:
    using B::f;               // D::f is private
};
 
int main() {
    D d;

//  d.x = 2; // ERROR, private
//  d.n = 2; // ERROR, protected
    d.m = 2; // protected B::m is accessible as D::m

    d.set_n(2); // calls B::set_n(int)
    cout << d.get_n() << endl; // output: 2

//  d.f();   // ERROR, B::f is inaccessible as D::f


    B& b = d; // b references d and "views" it as being type B

//  b.x = 3; // ERROR, private
//  b.n = 3; // ERROR, protected
//  b.m = 3; // ERROR, B::m is protected

    b.set_n(3); // calls B::set_n(int)
//  cout << b.get_n(); // ERROR, 'struct B' has no member named 'get_n'

    b.f();   // calls B::f()
    return 0;
}

Referanser

Merknader

Bibliografi

• Mayo, Joseph (2002), C Sharp Unleashed , Sams publisering, ISBN   9780672321221