écriture d'une classe avec objet en argument

[HommeCocoa]

Bonsoir,

J'ai une question toute bête, j'essaie d'écrire une classe Vecteur où il y aurait une méthode permettant de créer un vecteur en en additionnant deux autres.

Donc si on veut bien, ça me créerait un objet de cette classe à partir de deux autres objet de cette même classe passé en argument

J'ai pensé à quelque chose comme ça:

- (Vecteur *)add: (Vecteur *)vecteur1 ......


Mais après je ne sais pas comment mettre un deuxième objet en argument et de plus même avec un seul, Xcode me dit que les méthode n'accèpte pas d'objet en arguement

Je suis un peu pommé!
David

 

[molgow]

Une méthode avec plusieurs arguments s'écrira de cette façon :

-(Vecteur *) add:(Vecteur *)vecteur1 with:(Vecteur *)vecteur2

Mais ça serait pas une très bonne conception orientée-object.
Le mieux c'est d'avoir une méthode :

-(Vecteur *) addWith:(Vecteur *)vecteur

qui retournera la somme de l'objet vecteur receveur (celui qui reçoit l'appel de méthode) avec le vecteur "vecteur" passé en paramètre.

 

[HommeCocoa]

merci beaucoup pour une réponse si rapide!

J'ai vite testé ceci en faisant une classe encore plus simple... la classe Entier

mais il y a toujours un problème, en faite j'ai pas bien compris comment faire le "return" de la méthode quand il s'agit d'un objet

#import "Entier.h"

@implementation Entier

- (void)init
{
  nombre = 0;
}

- (int)getNombre
{
  return nombre;
}

- (void)setNombre:(int)nombreRecu
{
  nombre = nombreRecu;
}

- (void)oppose
{
 nombre = nombre*(-1);
}

- (Entier *)addWith:(Entier *)entierRecu
{
  return (entierRecu + nombre);
}

@end

Dans mon cas, c'est très bête car mon return retourn un vrai int et non pas l'objet entier que j'ai créé

:heu:

Qu'est ce que je dois faire pour que ça soit un objet qui soit retourné?

 

[molgow]

Il te faut faire quelque chose du style...

Je pense qu'il te faudra aussi rajouter qqch comme un autorelease. Je suis pas spécialiste d'Objective-C... J'essaie de regarder à moins que quelqu'un réponde avant.

- (Entier *)addWith:(Entier *)entierRecu
{
  Entier *e = [[Entier alloc] init];
  [e setNombre:(nombre + [entierRecu getNombre])];
  return e;
}

 

[HommeCocoa]

J'ai réecrit ma classe comme ceci:

#import "Entier.h"

@implementation Entier

- (void)init
{
  nombre = 0;
}

- (int)getNombre
{
  return nombre;
}

- (void)setNombre:(int)nombreRecu
{
  nombre = nombreRecu;
}

- (void)oppose
{
 nombre = nombre*(-1);
}

- (Entier *)addWith:(Entier *)entierRecu
{
  Entier *e;
    
  e = [[Entier alloc] init];
  
  int nouv;
  nouv = nombre + [entierRecu getNombre];
  
  [e setNombre:nouv];
  return e;
}

@end

puis dans le main j'ai mis:

#import <Cocoa/Cocoa.h>

#import "Entier.h"

int main(int argc, char *argv[])
{

	NSLog(@"Hello");
	
	Entier *exemple;
	exemple = [[Entier alloc] init];
	
	Entier *le_nombre;
	le_nombre = [[Entier alloc] init];
	
	[exemple setNombre:4];
	
	
	[le_nombre setNombre:8];
	
	printf("%d\n", [exemple getNombre]);
	printf("%d\n", [le_nombre getNombre]);
	
	[exemple addWith:le_nombre];
	
	printf("%d\n", [exemple getNombre]);

	
	




//    return NSApplicationMain(argc,  (const char **) argv);
}

mais au final dans la consol, je resors avec un 4 alors que ça devrait plutôt être 12, il y a encore un truc qui va pas, je sais pas vraimnet quoi :siffle:

 

[HommeCocoa]

Hmmmm je crois que finalement, c'est encore mieux de faire ça:

- (void)addWith:(Entier *)entierRecu
{
  nombre = nombre + [entierRecu getNombre]; 
}

tout bêtement non?

 

[molgow]

Entier.m :

#import "Entier.h"

@implementation Entier

- (id)init
{
  self = [super init];
  nombre = 0;
  return self;
}

- (int)getNombre
{
  return nombre;
}

- (void)setNombre:(int)nombreRecu
{
  nombre = nombreRecu;
}

- (void)oppose
{
 nombre = nombre*(-1);
}

- (Entier *)addWith:(Entier *)entierRecu
{
  Entier *e;
    
  e = [[Entier alloc] init];
  
  int nouv;
  nouv = nombre + [entierRecu getNombre];
  
  [e setNombre:nouv];
  return e;
}

@end

Entier.h :

@interface Entier : NSObject {
    int nombre;
}
- (int)getNombre;
- (void)setNombre:(int)nombreRecu;
- (void)oppose;
- (Entier *)addWith:(Entier *)entierRecu;
@end

main.m :

#import "Entier.h"

int main(int argc, char *argv[])
{
    NSLog(@"Hello");
    
    Entier *exemple = [[Entier alloc] init];
    Entier *le_nombre = [[Entier alloc] init];
    
    [exemple setNombre:4];
    [le_nombre setNombre:8];
    
    printf("%d\n", [exemple getNombre]);
    printf("%d\n", [le_nombre getNombre]);
    
    Entier *somme = [exemple addWith:le_nombre];
    
    printf("%d\n", [somme getNombre]);
    
    return 0;
}

Le problème était que tu faisais l'addition mais la stockait nulle part, et ensuite tu imprimais le nombre "exemple". Donc forcément, ça réimprimait sa valeur qui vaut 4 (et qui ne change jamais au cours de l'exécution).

 

[HommeCocoa]

haaa oui biensur!

c'est assez bête!

Je vais vite modifier ça

Merci encore

 

[HommeCocoa]

Bon j'ai refais tout ça pour une classe Vecteur: Est-ce que ça semble être une programmation "propre" ? Je suis en train de me dire que je n'ai fais aucun release... c'est louche (le java c'est quand même pas mal pour ça)

Vecteur.h

@interface Vecteur : NSObject
{
	float composante1;
	float composante2;
}

- (void)init;

- (void)setComposante1:(float)floatRecu1;
- (void)setComposante2:(float)floatRecu2;

- (float)getComposante1;
- (float)getComposante2;

- (float)pente;

- (Vecteur *)addWith:(Vecteur *)vecteurRecu;



@end

Vecteur.m

@implementation Vecteur

- (void)init
{
  composante1 = 0;
  composante2 = 0;
}

- (void)setComposante1:(float)floatRecu1
{
  composante1 = floatRecu1;
}

- (void)setComposante2:(float)floatRecu2
{
  composante2 = floatRecu2;
}

- (float)getComposante1
{
  return composante1;
}

- (float)getComposante2
{
  return composante2;
}

- (float)pente
{
  return composante2/composante1;
}

- (Vecteur *)addWith:(Vecteur *)vecteurRecu
{
  Vecteur *nouveauVecteur;
  
  nouveauVecteur = [[Vecteur alloc] init];
  
  [nouveauVecteur setComposante1:([vecteurRecu getComposante1] + composante1)];
  [nouveauVecteur setComposante2:([vecteurRecu getComposante2] + composante2)];
  
  return nouveauVecteur;
}



@end

le main

int main(int argc, char *argv[])
{


	
	Vecteur *monPremierVecteur;
	Vecteur *monSecondVecteur;
	Vecteur *monTroisiemeVecteur;

    monPremierVecteur = [[Vecteur alloc] init];
	monSecondVecteur = [[Vecteur alloc] init];

	
	[monPremierVecteur setComposante1:4];
	[monPremierVecteur setComposante2:4];
	
	[monSecondVecteur setComposante1:2];
	[monSecondVecteur setComposante2:6];
	
	monTroisiemeVecteur = [monPremierVecteur addWith:monSecondVecteur];
	
	printf("x : %f\n", [monPremierVecteur getComposante1]);
	printf("y : %f\n", [monPremierVecteur getComposante2]);
	
	printf("x : %f\n", [monSecondVecteur getComposante1]);
	printf("y : %f\n", [monSecondVecteur getComposante2]);
	
	printf("x : %f\n", [monTroisiemeVecteur getComposante1]);
	printf("y : %f\n", [monTroisiemeVecteur getComposante2]);
	
	

	
	


return 0;

//    return NSApplicationMain(argc,  (const char **) argv);
}