constructeur pour MyClass inst=valeur

**emmesse** · 04/12/2024, 13h52

bonjour,

je connais le constructeur:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class myclass{
myclasse(type objet);
...
};
 
myclass::myclass(type objet) {
...
}
 
int main(){
   myclass objet1(objet2);
}

Comment déclarer un constructeur qui permette ceci?:

Code :

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

myclass objet1=objet2;

une idée?

**dalfab** · 04/12/2024, 14h49

Bonjour,

Pour la construction avec =, elle indique que l'on ne veut pas une construction directe mais une construction par copie (à ne pas confondre avec une assignation par copie). Le compilateur produit comme si on avait écrit myclass objet1 = myclass(objet2);, on crée un temporaire construit à partir de objet2 et on créé objet1 à partir de ce temporaire.

Ça doit donc directement marcher, à moins que tu n'aies ajouté d'autres contraintes (constructeur par copie inaccessible, accès explicit au constructeur, ambiguïté, ...)

Et la solution est dans l'ajustement, la correction ou le contournement de ces contraintes, nécessite plus d'infos dont le texte exact de l'erreur indiquée.

**emmesse** · 04/12/2024, 15h20

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <string>
class myclass{
public:
  myclass(std::string valeur);
};
 
int main(){
  std::string valeur="abc";
  myclass objet=valeur;
  myclass objet2="456";
  myclass objet3("esdfg");
}

"myclass objet= valeur" fonctionne, "myclass objet3("esdfg") aussi, mais pas "myclass objet2="456""

est-il possible de construire, avec '=', à partir d'une chaine?

Code :

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

1
2
3
4
main.cpp: In function ‘int main()’:
main.cpp:10:18: error: conversion from ‘const char [4]’ to non-scalar type ‘myclass’ requested
   10 |   myclass objet2="456";
      |                  ^~~~~

**Bktero** · 04/12/2024, 17h14

Un const char* n'est pas une std::string.

Tu n'as pas de constructeur qui accepte un const char* donc le compilateur n'est pas content.

Il te faut un myclass(const char* valeur);

**emmesse** · 04/12/2024, 19h44

merci pour vos réponses.

autre problème: ambigous
voici mes constructeurs;

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
nombre::nombre() { }
 
nombre::nombre(const char * valeur_init){
  std::string copie(valeur_init);
  if(copie.at(0)=='-'){
    positif=false;
    copie=copie.substr(1);
  }
  else if(copie.at(0)=='+'){
    positif=true;
    copie=copie.substr(1);
  }
  else
    positif=true;
  int indice=copie.find(',');
  if(indice!=std::string::npos){
    partie_entiere=copie.substr(0,indice);
    partie_decimale=copie.substr(indice+1);
  }
  else{
    partie_entiere=copie;
    partie_decimale="0";
  }
  *this=this->normalise();
}
 
nombre::nombre(nombre const &nb){
  positif=nb.positif;
  partie_entiere=nb.partie_entiere;
  partie_decimale=nb.partie_decimale;
}
 
nombre::nombre(std::string const &valeur_init){
  std::string copie(valeur_init);
  if(copie.at(0)=='-'){
    positif=false;
    copie=copie.substr(1);
  }
  else if(copie.at(0)=='+'){
    positif=true;
    copie=copie.substr(1);
  }
  else
    positif=true;
  int indice=copie.find(',');
  if(indice!=std::string::npos){
    partie_entiere=copie.substr(0,indice);
    partie_decimale=copie.substr(indice+1);
  }
  else{
    partie_entiere=copie;
    partie_decimale="0";
  }
  *this=this->normalise();
}

ma fonction 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
22
23
24
25
26
27
28
#include <string>
#include <iostream>
 
#include "nombre.hpp"
#include "operateurs.hpp"
 
int main(){
  std::string a,b,c;
  std::cin>>a>>b>>c;
  nombre n1,n2,n3("123");
  n1=a;
  n2=b;
  n3=c;
  nombre n4("215565845");
  std::cout<<n4<<std::endl;
  std::cout<<n1<<" + "<<n2<<" = "<<n1+n2<<std::endl;
  std::cout<<n1<<" - "<<n2<<" = "<<n1-n2<<std::endl;
  std::cout<<n1<<" * "<<n2<<" = "<<n1*n2<<std::endl;
  std::cout<<n1<<" ^ "<<n2<<" = "<<n1.exposant(n2)<<std::endl;
  n1+=n2;
  std::cout<<"+ "<<n2<<" =  "<<n1<<std::endl;
  n1-=n2;
  std::cout<<"- "<<n2<<" = "<<n1<<std::endl;
  n1*=n2;
  std::cout<<"* "<<n2<<" = "<<n1<<std::endl;
  n4=n3=n2=n1;
  std::cout<<n1<<" "<<n2<<" "<<n3<<" "<<n4<<std::endl;
}

et voici les message d'erreur:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
$ g++ -g -o test *cpp
nombre.cpp: In member function ‘nombre nombre::operator*(const nombre&) const’:
nombre.cpp:185:12: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  185 |   resultat="0";
      |            ^~~
In file included from nombre.cpp:4:
nombre.hpp:28:11: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
   28 |   nombre& operator=(std::string const &nombre_str);
      |           ^~~~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:190:10: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  190 |       un="1";
      |          ^~~
nombre.hpp:28:11: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
   28 |   nombre& operator=(std::string const &nombre_str);
      |           ^~~~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp: In member function ‘nombre nombre::exposant(const nombre&) const’:
nombre.cpp:371:14: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  371 |     resultat="0";
      |              ^~~
nombre.cpp:221:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  221 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:374:14: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  374 |     resultat="1";
      |              ^~~
nombre.cpp:221:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  221 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:380:12: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  380 |         un="1";
      |            ^~~
nombre.cpp:221:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  221 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~

avez-vous une idée?

**emmesse** · 04/12/2024, 19h46

je comprends: il faut une surcharge de operator=(const char* valeur_init)
je vais essayer cela et je reviens

**emmesse** · 04/12/2024, 19h54

non ça ne fonctionne pas encore

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
nombre& nombre::operator=(const char *nombre_str){
  std::string copie(nombre_str);
  if(copie.at(0)=='-'){
    positif=false;
    copie=copie.substr(1);
  }
  else if(copie.at(0)=='+'){
    positif=true;
    copie=copie.substr(1);
  }
  else
    positif=true;
  int indice=copie.find(',');
  if(indice!=std::string::npos){
    partie_entiere=copie.substr(0,indice);
    partie_decimale=copie.substr(indice+1);
  }
  else{
    partie_entiere=copie;
    partie_decimale="0";
  }
  *this=this->normalise();
  return *this;
}
 
nombre& nombre::operator=(std::string const &nombre_str){
  std::string copie(nombre_str);
  if(copie.at(0)=='-'){
    positif=false;
    copie=copie.substr(1);
  }
  else if(copie.at(0)=='+'){
    positif=true;
    copie=copie.substr(1);
  }
  else
    positif=true;
  int indice=copie.find(',');
  if(indice!=std::string::npos){
    partie_entiere=copie.substr(0,indice);
    partie_decimale=copie.substr(indice+1);
  }
  else{
    partie_entiere=copie;
    partie_decimale="0";
  }
  *this=this->normalise();
  return *this;
}

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
28
29
30
31
nombre::nombre() { }
 
nombre::nombre(const char * valeur_init){
  std::string copie(valeur_init);
  if(copie.at(0)=='-'){
    positif=false;
    copie=copie.substr(1);
  }
  else if(copie.at(0)=='+'){
    positif=true;
    copie=copie.substr(1);
  }
  else
    positif=true;
  int indice=copie.find(',');
  if(indice!=std::string::npos){
    partie_entiere=copie.substr(0,indice);
    partie_decimale=copie.substr(indice+1);
  }
  else{
    partie_entiere=copie;
    partie_decimale="0";
  }
  *this=this->normalise();
}
 
nombre::nombre(nombre const &nb){
  positif=nb.positif;
  partie_entiere=nb.partie_entiere;
  partie_decimale=nb.partie_decimale;
}

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
$ g++ -g -o test *cpp
nombre.cpp: In member function ‘nombre nombre::operator*(const nombre&) const’:
nombre.cpp:185:12: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  185 |   resultat="0";
      |            ^~~
In file included from nombre.cpp:4:
nombre.hpp:28:11: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
   28 |   nombre& operator=(std::string const &nombre_str);
      |           ^~~~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:190:10: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  190 |       un="1";
      |          ^~~
nombre.hpp:28:11: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
   28 |   nombre& operator=(std::string const &nombre_str);
      |           ^~~~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp: At global scope:
nombre.cpp:221:9: error: no declaration matches ‘nombre& nombre::operator=(const char*)’
  221 | nombre& nombre::operator=(const char *nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidates are: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.hpp:28:11: note:                 ‘nombre& nombre::operator=(const std::string&)’
   28 |   nombre& operator=(std::string const &nombre_str);
      |           ^~~~~~~~
nombre.hpp:4:7: note: ‘class nombre’ defined here
    4 | class nombre{
      |       ^~~~~~
nombre.cpp: In member function ‘nombre nombre::exposant(const nombre&) const’:
nombre.cpp:397:14: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  397 |     resultat="0";
      |              ^~~
nombre.cpp:246:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  246 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:400:14: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  400 |     resultat="1";
      |              ^~~
nombre.cpp:246:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  246 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~
nombre.cpp:406:12: error: ambiguous overload for ‘operator=’ (operand types are ‘nombre’ and ‘const char [2]’)
  406 |         un="1";
      |            ^~~
nombre.cpp:246:9: note: candidate: ‘nombre& nombre::operator=(const std::string&)’
  246 | nombre& nombre::operator=(std::string const &nombre_str){
      |         ^~~~~~
nombre.hpp:4:7: note: candidate: ‘nombre& nombre::operator=(const nombre&)’
    4 | class nombre{
      |       ^~~~~~

une idée?

**emmesse** · 04/12/2024, 20h07

et si je faisais:

Code :

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

1
2
std::string nouveau="123"
nombre n(nouveau)

**emmesse** · 04/12/2024, 20h21

ça y est ça fonctionne
j'avais oublié ce prototype dans la classe:

Code :

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

nombre& operator=(const char * nombre_str);

constructeur pour MyClass inst=valeur

Langage C++

Discussions similaires

Partager

Partager