Metodi Obj-C: chiamata con parametri

Question

Sto usando le funzioni in stile C, ma ho appena imparato che non possono vedere le variabili di istanza. Quindi mi è stato consigliato di convertirli in metodi Objective-C.

NSString* myfunc ( int x )

diventa:

- (NSString *)myfunc:(int)x

e

myString = myfunc(x);

diventa

myString = [myString myfunc:x];

??

Questo viene compilato con avvisi minacciosi, ma non funziona. Che cosa ho capito male?

Answer 1

Sembra che la tua chiamata sia errata. Forse prova:

NSString *myString = [self myfunc:x];

Answer 2

Per quanto ho capito, invii il messaggio -myfunc: a un oggetto NSString. Quindi il metodo -myfunc: dovrebbe essere dichiarato nella classe NSString (o una categoria di NSString ).

Se questo è ciò che si desidera fare, non è necessario restituire l'oggetto stesso come risultato del metodo: è possibile modificare le sue variabili di istanza nell'implementazione del metodo. La chiamata del metodo (o l'invio di messaggi) è simile a:

[myString myfunc:x];

Se si desidera inviare il messaggio a un oggetto di un'altra classe e restituire una stringa, la dichiarazione del metodo è corretta ma deve apparire nell'implementazione della classe e nel destinatario del messaggio (questo è l'elemento a sinistra nel quadrato parentesi) devono appartenere a quella classe:

@implementation MyClass
-(NSString *)myfunc:(int)x
{
    NSString * returnString;
    ...// do something with x, returnString and instance variables
    return returnString;
}
@end;
...
MyClass * myobj = [[MyClass alloc] init];
NSString * myString = [myobj myfunc:42];

Answer 3

Come seconda risposta, sto cercando di capire il tuo problema attraverso tutte le tue domande recenti.

All'inizio del , c'era una funzione C che restituiva un puntatore a un Oggetto NSString :

NSString * myfunc( int x )
{
           ... // Do something with x
   NSString * myString = @"MYDATA";
           ... // Do something with myString
   return myString;        
}

Quindi , hai voluto aggiungere in quella funzione del codice su un UIImage oggetto:

image1.image = [UIImage imageNamed:@"image1.png"];

Ti è stato consigliato di convertire la funzione in un metodo. Se si desidera accedere alla variabile di istanza .image , questo metodo deve appartenere alla classe dell'oggetto image1 (diciamo che si tratta della classe AlanImage ) . Qualcosa del genere:

@interface AlanImage : NSObject {
    UIImage image;
}
- (NSString *) myfuncWithParam: (int) x;
@end;

@implementation AlanImage
- (NSString *) myfuncWithParam: (int) x
{
    NSString * myString = @"MYDATA";
    image = [UIImage imageNamed:@"image1.png"];
    return myString;        
}
@end

Third , non sapevi cosa fosse il destinatario del metodo. Le mie indagini tendono a portare il tuo oggetto image come un buon candidato:

aNiceString = [image myfunc:aNiceInteger];

Infine (questa domanda), non ottenendo una risposta soddisfacente, hai riformulato la tua terza domanda, questa volta con successo con successo.

Sono curioso di avere una visione più completa del tuo progetto per darti qualche suggerimento. Ad ogni modo, sembra che tu stia imparando Objective-C e concetti orientati agli oggetti: congratulazioni e rimani motivato!

Answer 4

Non hai capito cosa sia Programmazione orientata agli oggetti . Con [theObject method] puoi solo chiamare metodi appartenenti all'istanza specifica.

Answer 5

Non sono sicuro che il trucco seguente funzioni correttamente per un " generale " goal-c, ma nell'implementazione di Apple puoi farlo:

@interface SomeClass: NSObject {
  int m_someVariable;
  ...
};

- (NSString *) someMethod;
...
@end 

@implementation SomeClass
...
//pure c function with extra one parameter 
//for accessing to instance variables
static NSString privatePlainCeeMethod(SomeClass *my, int fortyTwo) {
  NSString *str;
  //access to a instance variable as for a usual
  //cee structure field: my->fieldName
  ...
  return [NSString stringWithFormat:@"someVariable:%d, fortyTwo:%d",
    my->m_someVariable, fortyTwo];
};

- (NSString *) someMethod  { 
  ...
  return privatePlainCeeMethod(self,42);
};
...
@end

Uso questo trucco per dividere un grande metodo objc su semplici funzioni private osservabili. Queste funzioni (a) non inquinano l'interfaccia di classe e (b) sono invocate più velocemente del metodo objc.