Que signifie «@private» dans Objective-C?

Que @privatesignifie dans Objective-C?

Il s'agit d'un modificateur de visibilité - cela signifie que les variables d'instance déclarées comme @privatene sont accessibles qu'aux instances de la même classe . Les membres privés ne sont pas accessibles par les sous-classes ou autres classes.

Par exemple:

@interface MyClass : NSObject
{
    @private
    int someVar;  // Can only be accessed by instances of MyClass

    @public
    int aPublicVar;  // Can be accessed by any object
}
@end

De plus, pour clarifier, les méthodes sont toujours publiques dans Objective-C. Il existe cependant des moyens de "masquer" les déclarations de méthode - consultez cette question pour plus d'informations.

Comme l'a dit htw, c'est un modificateur de visibilité. @privatesignifie que l'ivar (variable d'instance) n'est accessible directement qu'à partir d'une instance de la même classe. Cependant, cela ne signifie peut-être pas grand-chose pour vous, alors laissez-moi vous donner un exemple. Nous utiliserons les initméthodes des classes comme exemples, par souci de simplicité. Je commenterai en ligne pour signaler les éléments d'intérêt.

@interface MyFirstClass : NSObject
{
    @public
    int publicNumber;

    @protected  // Protected is the default
    char protectedLetter;

    @private
    BOOL privateBool;
}
@end

@implementation MyFirstClass
- (id)init {
    if (self = [super init]) {
        publicNumber = 3;
        protectedLetter = 'Q';
        privateBool = NO;
    }
    return self;
}
@end

@interface MySecondClass : MyFirstClass  // Note the inheritance
{
    @private
    double secondClassCitizen;
}
@end

@implementation MySecondClass
- (id)init {
    if (self = [super init]) {
        // We can access publicNumber because it's public;
        // ANYONE can access it.
        publicNumber = 5;

        // We can access protectedLetter because it's protected
        // and it is declared by a superclass; @protected variables
        // are available to subclasses.
        protectedLetter = 'z';

        // We can't access privateBool because it's private;
        // only methods of the class that declared privateBool
        // can use it
        privateBool = NO;  // COMPILER ERROR HERE

        // We can access secondClassCitizen directly because we 
        // declared it; even though it's private, we can get it.
        secondClassCitizen = 5.2;  
    }
    return self;
}

@interface SomeOtherClass : NSObject
{
    MySecondClass *other;
}
@end

@implementation SomeOtherClass
- (id)init {
    if (self = [super init]) {
        other = [[MySecondClass alloc] init];

        // Neither MyFirstClass nor MySecondClass provided any 
        // accessor methods, so if we're going to access any ivars
        // we'll have to do it directly, like this:
        other->publicNumber = 42;

        // If we try to use direct access on any other ivars,
        // the compiler won't let us
        other->protectedLetter = 'M';     // COMPILER ERROR HERE
        other->privateBool = YES;         // COMPILER ERROR HERE
        other->secondClassCitizen = 1.2;  // COMPILER ERROR HERE
    }
    return self;
}

Donc, pour répondre à votre question, @private protège les ivars contre l'accès par une instance de toute autre classe. Notez que deux instances de MyFirstClass peuvent accéder directement à tous les ivars respectifs; il est supposé que puisque le programmeur a un contrôle complet direct sur cette classe, il utilisera cette capacité à bon escient.

Il est important de comprendre ce que cela signifie lorsque quelqu'un dit que vous ne pouvez pas accéder à une @privatevariable d'instance. La vraie histoire est que le compilateur vous donnera une erreur si vous essayez d'accéder à ces variables dans votre code source. Dans les versions précédentes de GCC et XCode, vous receviez simplement un avertissement au lieu d'une erreur.

De toute façon, au moment de l'exécution, tous les paris sont désactivés. Ces objets @privateet @protectedivars sont accessibles par un objet de n'importe quelle classe. Ces modificateurs de visibilité rendent difficile la compilation du code source en code machine qui viole l'intention des modificateurs de visibilité.

Ne vous fiez pas aux modificateurs de visibilité ivar pour la sécurité! Ils n'en fournissent aucun. Ils sont strictement destinés à l'application au moment de la compilation des souhaits du constructeur de classe.