Qualificatori di accesso pubblici, privati ​​e protetti per le classi D

Question

Sono un programmatore C++ che inizia con D e ho difficoltà a comprendere i qualificatori di accesso per le classi D. Si consideri il seguente esempio:

import std.stdio; 

class Foo { 

    private void aPrivateMethod() 
    { 
     writeln("called aPrivateMethod"); 
    } 

    protected void aProtectedMethod() 
    { 
     writeln("called aProtectedMethod"); 
    } 

    public void aPublicMethod() 
    { 
     this.aPrivateMethod(); 
     this.aProtectedMethod(); 
    } 
} 

void main(string[] args) 
{ 
    Foo foo = new Foo(); 

    foo.aPublicMethod(); // OK to call it from anywhere 
    foo.aPrivateMethod(); // Must not be allowed to call it outside Foo 
    foo.aProtectedMethod(); // Should only be callable from within Foo and derived classes 
} 

mi aspetterei che il precedente codice di fallire la compilazione, dal momento che sta chiamando i metodi privati ​​e protetti della classe Foo in una funzione esterna. Tuttavia, questo non è il caso, poiché l'esempio sopra compila ed esegue senza errori o avvisi su DMD v2.063.2. Chiaramente le parole chiave hanno un significato diverso da quelle del C++.

Le mie domande sono:

1) Come fare un metodo e/o variabile privata a una classe in modo che solo la classe in questione può accedervi.

2) Come rendere protetto un metodo e/o una variabile, in modo che solo la classe in questione e le sue classi derivate possano accedervi.

Answer 1

i modificatori di accesso sono a livello di modulo/file di (unica eccezione è protetto)

per rimuovere l'accesso a una classe metterlo nella propria mudule:

foo.d

import std.stdio; 
class Foo { 

    private void aPrivateMethod() 
    { 
     writeln("called aPrivateMethod"); 
    } 

    protected void aProtectedMethod() 
    { 
     writeln("called aProtectedMethod"); 
    } 

    public void aPublicMethod() 
    { 
     this.aPrivateMethod(); 
     this.aProtectedMethod(); 
    } 
} 

principale .d

import foo; 

void main(string[] args) 
{ 
    Foo foo = new Foo(); 

    foo.aPublicMethod(); // OK to call it from anywhere 
    foo.aPrivateMethod(); // compile error: Must not be allowed to call it outside foo.d 
    foo.aProtectedMethod(); // compile error: Should only be callable from within foo.d, Foo and derived classes 
} 

Answer 2

D ha un significato leggermente diverso per i termini pubblico privato e protected than C++

Privato significa che solo i membri della classe che li chiude possono accedere al membro, o ai membri e alle funzioni nello stesso modulo della classe che li contiene. I membri privati ​​non possono essere ignorati. I membri del modulo privato sono equivalenti alle dichiarazioni statiche nei programmi C.

Il pacchetto si estende in modo tale da consentire l'accesso ai membri del pacchetto dal codice negli altri moduli inclusi nello stesso pacchetto. Questo vale solo per il pacchetto più interno, se un modulo è in pacchetti nidificati.

Protetto significa che solo i membri della classe che acclude o qualsiasi classe derivata da quella classe, o membri e funzioni nello stesso modulo della classe di inclusione, possono accedere al membro. Se si accede a un membro dell'istanza protetto tramite una funzione membro della classe derivata, è possibile accedere a tale membro solo per l'istanza dell'oggetto che può essere convertita implicitamente nello stesso tipo di "this". I membri del modulo protetto sono illegali.

Pubblico significa che qualsiasi codice all'interno dell'eseguibile può accedere al membro.