Discussion :

[persé]

Bonjour ;

je viens de commencer c++ , je veux faire un appel a une classe:
le main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
#include "stdafx.h"
#include <iostream>
#include "fonction.h"
using namespace std;
 
int main()
{
	fonction f ;
	int s;
	int d;
	s = f.somm(4, 6);
	d = s + 45;
	//int es(56);
 
	cout << "la fonction retourne  : " << s << endl;
	system("PAUSE");
	return 0;
}

la classe fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
#include "stdafx.h"
#include "fonction.h"
#include <iostream>
using namespace std;
class fonction{
 
 
 
 
public:
 
	void fonction::aff(){
 
		cout << "appel fonction !" << endl;
	}
 int fonction::  somm(int a, int b){
		int somm(0);
 
		somm = a + b;
 
		return somm;
 
	}
 
 
};

je suis sur visual l'erreur est :
Erreur 1 error C2011: 'fonction'*: redéfinition du type 'class'

je ne comprends pas la cause svp

[handetaker]

En faite lorsque le compilateur arrive à

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

 #include "fonction.h" (à la ligne 3 de ton code )

il y accède et retient qu'il existe une classe qui porte le nom "fonction" .Lorsqu'il sort de

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

 #include "fonction.h"

il croise de nouveau cette classe que tu as nommé "fonction" (à la ligne 6 de ton code) du coup il ne supporte pas ça! il y'a bien une redéfinition de ta classe!. Commence par supprimer l'écriture

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

#include "fonction.h"

De plus il est interdit d'écrire :

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void fonction::aff(){
 
		cout << "appel fonction !" << endl;
	}

dans le fichier.h . par contre tu peux l'écrire dans un fichier .cpp avec l'appele de

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

 #include "fonction.h"

.LE fichier .h doit uniquement contenir les noms de tes constructeurs ,destructeur(utile si tu utilises des pointeurs,mais il est quand même important de le mettre ),les noms de tes fonction et de tes accesseurs qui te permettront de modifier ou de lire le contenu de tes variables privées.Exemple :
public:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
	void aff();
 int somm(int , int );
etc..

Du coup si tu veux directement implémenter tes fonctions dans le fichier .h tu peux le faire de la manière suivante:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 inline  void aff(){
 
		cout << "appel fonction !" << endl;
	}
 inline int  somm(int a, int b){
		int somm(0);
 
		somm = a + b;
 
		return somm;
 
	}

je t'invite aussi à lire ceci --->

http://cpp.developpez.com/faq/cpp/?page=inline

Bon courage!

[persé]

Merci pour votre réponse :
mais si je supprimer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include "fonction.h"

de la classe principale ,qui contient le main comment je vais pour l'appeler ,il y' aura une erreur .

[handetaker]

juste un aperçus d'un fichier .h:
pour une bonne exécution du programme (fait des recherches dessus ) il est tout d'abord utile de structurer ton fichier .h de la manière suivante:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef NOM_DU_FICHIER_H
#define NOM_DU_FICHIER_H
Class NOM_DE_LA_CLASSE
{
private:     //ou public comme tu veux ;)
attribut1;
attribut2;
public:
 NOM_DE_LA_CLASSE(...)//constructeur1
NOM_DE_LA_CLASSE(...)//constructeur2
etc..
type Nom_fonction1(..);//type=int,float,etc..
type Nom_fonction2(..);
etc....
~NOM_DE_LA_CLASSE() //destructeur
 
}
#endif

dans le fichier .cpp:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#include "NOM_DU_FICHIER.h"
 
NOM_DE_LA_CLASSE::NOM_DE_LA_CLASSE(..)//implémentation constructeur1
NOM_DE_LA_CLASSE::NOM_DE_LA_CLASSE(..)//implémentation constructeur2
type NOM_DE_LA_CLASSE::Nom_fonction1(..){}
type NOM_DE_LA_CLASSE::Nom_fonction2(..){}
NOM_DE_LA_CLASSE::~NOM_DE_LA_CLASSE(){}

il est possible que tu écrives le main dans ce fichier ,si c'est le cas n'oubli pas d'ajouter

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <iostream>

Bon courage !

[persé]

vous venez de me dire de supprimer les "nomclasse.h" !

voici mes trois fichiers

le .h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#pragma once
 
 
 
class fonction{
 
public:
	int somm(int a, int b);
 
	void aff(); 
 
};

le .ccp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include "stdafx.h"
#include "fonction.h"
#include <iostream>
using namespace std;
class fonction{
 
 
 
 
public:
 
	void fonction::aff(){
 
		cout << "appel fonction !" << endl;
	}
 int fonction::  somm(int a, int b){
		int somm(0);
 
		somm = a + b;
 
		return somm;
 
	}
 
 
};

le main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// classe.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <iostream>
#include "fonction.h"
using namespace std;
 
int main()
{
	fonction f ;
	int s;
	int d;
	s = f.somm(4, 6);
	d = s + 45;
	//int es(56);
 
	cout << "la fonction retourne  : " << s << endl;
	system("PAUSE");
	return 0;
}

[handetaker]

Je te l'ai demandé dans le cas ou tu l'avais écrit dans le même fichier. h.Tu n'as pas lu calmement mon dernier poste lis le et essaie de respecter la structure que je t'ai proposé.
L'implémentation de tes fonctions peuvent se faire directement avec le mot "inline" comme je te l'ai montré ou dans un fichier.cpp comme je te l'ai aussi montré.Tu peux soit ajouter le main dans le fichier.cpp qui contiendra l'implémentation des fonctions de ta classe ou, tu peux le créer dans un autre fichier qui contiendra les entêtes nécessaires à l’exécution de ton programme principale (#include<iostream> ,#include "NOM_DE_TON_FICHIER.h" etc..).

[persé]

j'ai suivit a la lettre j'ai ce petit souci avec cette ligne de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

s = fonction::somm(4, 6);

une reference de membre non statique doit etre relative a un objet statique

[handetaker]

j'ai suivit a la lettre j'ai ce petit souci avec cette ligne de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

s = fonction::somm(4, 6);

une reference de membre non statique doit etre relative a un objet statique

J'ai la flemme de te poser encore et encore des questions sans fin pour te demander d'être un peu plus claire dans tes réponses.
Alors je te propose ma solution que tu peux tester et modifier comme tu le sens(ce n'est pas LA SOLUTION mais UNE SOLUTION):

j'ai crée deux fichiers:fonction.h et fonction.cpp
Voici le contenu de fonction.h:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef FONCTION_H
#define FONCTION_H
 
class fonction
{
 
private:
	int a,b;
public:
	inline fonction(int val1,int val2)
	{
		a=val1;
		b=val2;
	};
	void aff();
	inline int geta(){return a;}//accesseur 
	inline int getb(){return b;}//accesseur (fait en des recherches dessus)
	inline void seta(int c){a=c;}//..
	inline void setb(int e){b=e;}//..
	inline int  somm(){ return a+b;} 
	inline ~fonction(){};
};
#endif

Voici le contenu de fonction.cpp:
(ps:si ça te dit tu peux toute fois créer un main.cpp)

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "fonction.h"
#include <iostream>
using namespace std;
 
//plus besoin d'implémenté tes fonctions puisqu'on l'aura fait directement dans le fichier.h
 
 
int main()
{
	fonction f(4,5);
	int s=f.somm();
	cout <<"somme="<<s<<endl;
}

Je sais que je me suis un peu écarter de ton idée de départ mais il est important de programmer la manière la plus simple possible pour te faciliter la tâche à toi même et à ceux qui voudrons comprendre ton programme!...Bon courage!

[Bousk]

Bonjour,

le code initial est presque bon.

Je suppose que le code de la classe que tu montres est le code du fichier fonction.cpp ?
Dans ce cas, il ne faut juste pas répéter class { dedans.

Il s'agit là de syntaxe classique et basique, il faudrait vraiment revoir les cours à ce sujet.

[handetaker]

Bonjour Ou es-ce que ,j'ai répété "class { " sacant que le fichier.h contient ma classe et l'implémentation de quelques fonction et que le fichier.cpp contient le main??? je ne te suis pas Bousk car je ne vois pas ou est le problème . DE Quel code initial parles-tu?Je suppose que tu apportes un élément de réponse à persé !? si c'est le cas ,ok .

[ternel]

Deux cas sont possibles.
- soit ta classe est triviale à coder, et tu ne fais pas de .cpp (auquel cas, toutes les fonctions seront "inline")

- soit ta classe est un peu complexe et il vaut mieux avoir un en-tête (.h ou .hpp) et un fichier d'implémentation (.cpp)

Dans les deux cas, ton main est bon. (j'ai supprimé tout usage de iostream)

Code main.cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include "fonction.h"
 
int main() {
	fonction f ;
	int s = f.somm(4, 6);
	return s;
}

si tu ne fais qu'un en-tête, ca donnerai ceci:

Code en tete seul :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#ifndef FONCTION_H
#define FONCTION_H
//une garde, pour éviter de se retrouver avec plusieurs fois le meme code, ce qui n'est pas compilable
//règle de la définition unique: chaque chose ne peut être définie qu'une et une seule fois. (elle peut être déclarée plusieurs fois)
 
//pourquoi inclure ceci, si tu ne l'utilise pas
//#include "stdafx.h"
 
//pas #include fonction.h, on est dedans
 
#include <iostream>
//certainement pas "using namespace std;" qui polluerait tout utilisation de cet entete
class fonction{
 
 public:
 	/*optionnel: inline*/ void aff(){
		std::cout << "appel fonction !" << std::endl;
	}
 
	/*optionnel: inline*/ int somm(int a, int b){
		int somm(0);
 		somm = a + b;
 		/*
 		int somm = a + b; serait préférable, pour éviter la création d'une temporaire.
 		après tout, le 0 qui est créé pour l'occasion n'a aucun intérêt.
 		ici, c'est un entier, ca ne joue pas vraiment, avec des classes ca peut devenir très lourd.
 		*/
 		return somm;
 		//finalement, la fonction se résume à return a + b;
 	}
};
 
//la fermeture de la garde
#endif

ou alors, en sortant les définitions de fonctions (pas les déclarations) de la définition du type "class fonction":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#ifndef FONCTION_H
#define FONCTION_H
 
#include <iostream>
 
class fonction{
public:
 	//déclarations.
 	void aff();
	int somm(int a, int b);
};
 
//définitions.
//inline devient obligatoire car la fonction sera défini dans chaque .cpp incluant fonction.h
 
inline void fonction::aff(){
	std::cout << "appel fonction !" << std::endl;
}
 
inline int fonction::somm(int a, int b){
	return a + b;
}
 
#endif /* FONCTION_H */

la solution de créer un cpp est tres ressemblante à celle ci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#ifndef FONCTION_H
#define FONCTION_H
//iostream n'est plus requis
class fonction{
public:
 	//déclarations.
 	void aff();
	int somm(int a, int b);
};
 
#endif /* FONCTION_H */

Code fonction.cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
//inclusion de l'entete défini, pour que le compilateur sache de quoi on parle
#include "fonction.h"
 
//les includes systèmes (en <>)
#include <iostream>
 
//d'autres includes perso (en "")
 
//inline serait faux.
void fonction::aff(){
	std::cout << "appel fonction !" << std::endl;
}
 
int fonction::somm(int a, int b){
	return a + b;
}

Je t'invite d'ailleurs à regarder les parties suivantes de la faq c++:
les fonctions inline
les fonctions membres statiques, parce qu'en l'état, somme et aff pourraient être "static"
pourquoi un const après la déclaration d'une fonction, comme ca pourrait être le cas de aff, si elle n'est pas static.
la surcharge d'opérateur, tout particulièrement, tu sera intéressé par operator() pour remplacer somm

exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Somme{
public:
	int operator() (int a, int b) const {
		return a + b;
	}
};
 
class Produit{
public:
	int operator() (int a, int b) const {
		return a * b;
	}
};
 
#include <iostream>
 
int main() {
	Somme somme;
	Produit produit;
	int a = 2, b = 3;
	std::cout<<"somme: "<< somme(a,b) <<" produit: " << produit(a,b)<< std::endl;
	return 0;
}

PS: ca fait du bien de revenir sur le forum

[persé]

Merci pour toutes vos reponses , leternel si j'utilise pas d'en-tete comment je vais l'appel de la fonction dans le main , je ne sais pas mais le code que j'ai fait en premier était juste non ?

On ma conseille de mettre mes fonctions dans un namespace et ça marche , est ce que c'est le bon choix .

leternel j'ai essai d’implémenter tes 3 fichiers mais ça ne marche pas !
merci a vous .

[ternel]

Tu m'as mis le doute, j'ai tout réessayé, pour moi, ca fonctionne très bien.

Je n'ai pas parlé de ne pas faire d'en-tête, mais je t'ai montré comment écrire une version avec seulement un en-tête (le contraire donc).
Effectivement, sans en-tête à inclure, la compilation ne pourrait pas réussir.

J'ai donné six fichiers, dans l'ordre:

1. main.cpp
2. fonction.h (en-tête seul, première version)
3. fonction.h (en-tête seul, seconde version)
   
4. fonction.h (en-tête pour implémentation séparée)
5. fonction.cpp (implémentation pour implémentation séparée)
   
6. exemple.cpp

il y a quatre combinaisons a tester:

• 1+2
• 1+3
• 1+4+5: compilation en deux temps possibles, base = 1+4, lib = 1+5, exe = link(base, lib)
• 6 un exemple pour l'avenir, autonome.

La suggestion du namespace est bonne.
Ici, ta classe fonction n'a pas vraiment d'intérêt en tant que telle.
L'objet fonction n'a pas de sens pratique.
Les fonctions qui sont dans la classe ne modifie pas l'objet, elle devrait être static.
Comme toutes les fonctions seraient static, la classe devient une sorte de "rien", qui ne fait prendre sous son nom des fonctions.
C'est exactement le rôle d'un namespace.