appel d'une fonction d'une classe

Version imprimable

bonjour,

1)j'écris dans un seul fichier sur www.replit.com ce petit code:

Code:

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
 
#include <string>
#include <stdio.h>
 
 
 
 class A{
 
   public:
 
  int mama(void)
  {
    int a,t1,t2;
    printf("entrez 1er entier: ");
    scanf("%d",&t1);
    printf("entrez 2ème entier: ");
    scanf("%d",&t2);
 
 
    a=t1+t2;
    return a;
  }
};
 
int main() {
 
  A objet;
  objet.mama();
  return 0;
 
}

Pourquoi ça ne fonctionne pas?

2)maintenant,dans le projet de replit.com,j'utilise 2 fichiers cpp

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
 
#include <string>
#include <stdio.h>
 
 
int main() {
 
  A objet;
  objet.mama();
  return 0;
 
}

puis fichier2.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
#include <string>
#include <stdio.h>
 
 
 
 class A{
 
   public:
 
  int mama(void)
  {
    int a,t1,t2;
    printf("entrez 1er entier: ");
    scanf("%d",&t1);
    printf("entrez 2ème entier: ");
    scanf("%d",&t2);
 
 
    a=t1+t2;
    return a;
  }
};

Est-ce que 2) est équivlent à 1) ?
Si non,pourquoi?
Comment corriger 2) pour obtenir l'équivalence?

merci de votre aide

03/12/2021, 03h49
Bousk

Cette ligne A.objet; n'a aucun sens.
Tu connais pas la syntaxe pour créer une variable ? :weird:
https://www.cplusplus.com/doc/tutorial/classes/
03/12/2021, 03h54
tabkelm

je repose la question corrigée
03/12/2021, 04h08
Bousk

:faq: https://cpp.developpez.com/faq/cpp/?...un-fichier-cpp

Bonjour,

La FAQ explique très bien comment utiliser les fichiers d'entête.
Il est important de comprendre que pour pouvoir utiliser la classe A, le main() doit connaitre toutes les caractéristiques accessible de A, on doit donc utiliser un #include.
Donc mettre ta classe dans un entête serait une solution. Mais tu coup ta fonction mama() se retrouve dans l'entête, ça marche mais pour des raisons de clarté et d'optimisation c'est à éviter. Il faut donc compiler 2 fichiers qui seraient "reliés" par un entête commun. Et n'utilise pas <stdio.h> et printf() c'est du C, tout comme mettre void comme paramètre, c'est toléré mais!
entete_a.h:
Code:

1 2 3 4 5 6 7 8 9 #ifndef ENTETE_A_H_ #define ENTETE_A_H_ class A { // la classe A est définie ici public: int mama(); // la fonction mama() de A est déclarée ici }; #endif
main.cpp
Code:

1 2 3 4 5 6 7 8 #include <iostream> #include "entete_a.h" int main() { A objet; // main() peut utiliser A car il l'a "vu" dans l'entête int resultat = objet.mama(); std::cout << "resultat : " << resultat << "\n"; }
a.cpp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <iostream> #include "entete_a.h" int A::mama() { // la fonction mama() de A est définie ici int t1, t2; std::cout << "entrez 1er entier: " << std::flush; std::cin >> t1; std::cout << "entrez 2ème entier: " << std::flush; std::cin >> t2; return t1 + t2; }

merci dalfab

de nouvelles petites questions se posent suite à la solution de dalfab
3)Le 1er code de dalfab est à inclure dans un fichier d'en tête par exemple entête.h
Est-ce bien cela?

4)j'ai l'impression qu'on a pas le droit d'implémenter le corps de la fonction mama dans la classe A:on peut seulement la déclarer.
Est-ce bien cela?

5)dans le fichier a.cpp ,on définit un constructeur de la classe A.
a)Est-ce bien cela?
b)aurait-on pu le définir dans le fichier d'entête dans la déclaration de la classe A comme ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #include <iostream> #ifndef ENTETE_A_H_ #define ENTETE_A_H_ class A { // la classe A est définie ici public: int mama(); // la fonction mama() de A est déclarée ici int A::mama() { int t1, t2; std::cout << "entrez 1er entier: " << std::flush; std::cin >> t1; std::cout << "entrez 2ème entier: " << std::flush; std::cin >> t2; return t1 + t2; } }; #endif

3) oui

4) oui et non. Tu ne dois pas définir de fonctions dans l'entête, tu ne dois y mettre que des déclarations. Mais une fonction peut être définie inline dans l'entête. Toute fonction définie dans l'objet lui-même est implicitement inline, toute fonction définie en dehors de l'objet n'est pas inline à moins d'ajouter devant le mot inline.

5.a) non. il n'y a aucun constructeur défini ou déclaré ici.

5.b) Essaie, et tu verras que ce que tu écris ne marche pas.
Tu peux mettre dans l'entête :
Code:

1 2 3 4 5 struct A { // la classe A est définie ici int mama() { // la fonction mama() de A est DEFINIE ici, et est implicitement INLINE ... ... ... } };
ou
Code:

1 2 3 4 5 6 struct A { // la classe A est définie ici int mama(); // la fonction mama() de A est DECLAREE ici }; inline int A::mama() { // la fonction est explicitement DEFINIE comme étant INLINE ... ... ... }
Mais c'est à éviter (oublie les pour le moment). La meilleure manière de procéder et celle que je t'avais donné avec la définition de la fonction dans un fichier source.

13/12/2021, 02h38
tabkelm
Dans la définition du fichier d'entête par dalfab:
Code:

1 2 3 4 5 6 7 8 9 10 #ifndef ENTETE_A_H_ #define ENTETE_A_H_ class A { // la classe A est définie ici public: int mama(); // la fonction mama() de A est déclarée ici }; #endif
ce fichier d'entête fonctionne aussi sans les instructions commençant par #
Quel est alors l'intérêt précis de ces instructions?
13/12/2021, 03h15
foetus
Citation:

Envoyé par tabkelm

Quel est alors l'intérêt précis de ces instructions?

"include guard" :mrgreen: :
1. wikipedia en français (<- lien)
2. wikipedia en anglais + complet (<- lien)