La Conversion des données à partir d'un type de classe à un autre type de classe

J'ai essayé de convertir un type de classe de données à un autre type de classe donc j'étais en utilisant l'opérateur de coulée méthode dans mon oops programme en c++.

class example2;
class example1
{
   int id;
   int numbers;
   int cost;
public:
   example1(int a, int b, int c)
   {
     id=a;
     numbers=b;
     cost=c;
   }

//getid() added here
//getnumber() added here
//getcost() added here

   operator example2()
   {
    example2 temp;
    temp.id=id;
    temp.value=numbers*cost;
    return temp;
   }
};
class example2
{
   int id;
   int value;
public:
   example2(int x,int y){
     id=x;
     value=y;
   }
  void display(){
    cout<<"id "<<id<<endl;
    cout<<"value "<<value<<endl;
  }
};

quand j'ai été en utilisant la conversion de exemple1 à exemple2. Il montre l'erreur.

int main()
{
  example1 s1(100,5,140.0);
  example2 s2;
  s2=s1;
  s2.display();
  return 0;
}

c'est de donner à l'erreur, mais pourquoi?. J'ai fait un opérateur de surcharger une fonction membre dans exemple1 classe parce que l'objet de exemple1 doit être changé en objet de exemple2.De sorte que cette fonction appelée à partir de la classe exemple1 de la méthode qui, je pense.Il doit être correct

D'erreur était:

erreur: le type de retour de la classe de exemple2 " est incomplète et
exemple2 temp; a incomplète de type

En quelque sorte, j'ai résolu d'une autre façon, j'ai ajouté un constructeur en exemple2 côté de classe:

example2(example1 e)
{
  id=e.getid(); //these functions already added in my code i didnt mentioned them in here.
  value=e.getnumber()*e.getcost();
}

et de faire des commentaires de 'l'opérateur exemple2 ()" dans exemple1.
maintenant, il est de travail.
Mais la manière n'était pas de l'accepter. Merci de m'aider à me corriger dans mon précédent façon de faire cette chose.

Le message d'erreur vous indique que vous avez besoin de plus que juste une déclaration anticipée de example2 au moment où vous avez example1 dans le code.
Je ne vois pas un seul tenant n'importe où dans le programme.
C'est la conversion d'un type classe de données à un autre type de classe de données.Je l'ai utilisé à partir de s2=s1.
Je veux que ce problème est résolu à partir de seulement une classe à l'opérateur qui ne prend aucun paramètre et ne retourne rien
Non, s2=s1 est juste l'attribution, en essayant de stuff s1 dans s2 et que peut ou mnay ne pas fonctionner selon les types de s2 et s1. Un casting change temporairement le type de données, vous permettant de traiter exemple2 comme un exemple1 et dans ce cas va dans le mur comme il n'y a pas de relation entre exemple2 et exemple1.
s2=s1 est l'attribution, mais il est d'appeler une fonction membre "de l'opérateur exemple2() "parce que s1 est exemple1 objet et je suis de l'affecter dans exemple2 objet s2.qui est comme exemple2 s2=exemple2(s1); ou exemple2 s2=s1; ici, l'opérateur sera invoquée par s1
Non, il n'est pas. s2=s1 est l'appel de l'opérateur=. Si vous voulez appeler votre fonte de surcharge, et vous ne le faites pas, il serait fait comme ceci: (example2)s1.

InformationsquelleAutor Aman Kaushal | 2015-07-18

c++oop

L'une des classes doivent être définies en premier et le deuxième ne peut être utilisé qu'après qu'il est défini. Cela signifie que vous avez à briser les définitions de classe un peu.

Voici un exemple de la façon d'obtenir à la classe qui n'est pas encore défini, basé sur de l'OP post. L'explication vient sous la forme de commentaires incorporés dans le code pour avoir un code tout en un cut-n-pasteable morceau.

#include <iostream>
class example2; //forward declaration to satisfy compiler until example2
//is defined
class example1
{
int id;
int numbers;
int cost;
public:
example1(int a, int b, int c)
{
id = a;
numbers = b;
cost = c;
}
example1(const example2 & e)  //the const and reference are just because
//no point copying e, and const ensures no
//side effects to e
{
*this = e;  //why duplicate code? Just calling operator=
}
example1& operator=(const example2 & e);
//note the lack of an implementation. This is because at this point
//the compiler only knows example2 exists, but not what it looks
//like. Can't copy what what you haven't seen.
int getid() const //const to allow me to use const references.
{
return id;
}
int getnumber() const
{
return numbers;
}
int getcost() const
{
return cost;
}
void display()
{
std::cout << "Example 1" << std::endl;
std::cout << "id " << id << std::endl;
std::cout << "numbers " << numbers << std::endl;
std::cout << "cost " << cost << std::endl;
}
};
class example2
{
int id;
int value;
public:
example2(int x, int y)
{
id = x;
value = y;
}
example2(const example1 &e)
{
*this = e;  //once again just calls the equals operator
}
example2 & operator=(const example1 & e) //OK. This time we know what
//example1 looks like and can
//actually implement the method
{
id = e.getid();
value = e.getnumber() * e.getcost();
return *this;
}
int getid() const
{
return id;
}
int getvalue()const
{
return value;
}
void display()
{
std::cout << "Example 2" << std::endl;
std::cout << "id " << id << std::endl;
std::cout << "value " << value << std::endl;
}
};
//and now for the implementation of example1's equals operator
example1& example1::operator=(const example2 & e)
{
id = e.getid();
numbers = -1; //do real work to get cost and numbers from e.getvalue()
cost = -1;
return *this;
}
int main()
{
example1 s1(100, 5, 140.0);
example2 s2(1, 2);
s2 = s1;
s2.display();
example2 s3(314, 278);
s1 = s3;
s1.display();
return 0;
}

Maintenant pour la surcharge de l'opérateur de cast. C'est quelque chose que vous presque jamais envie de le faire parce qu'il y a presque toujours beaucoup plus de moyens évidents pour atteindre le même objectif.

Par exemple:

#include<iostream>
class Integer
{
public:
Integer(int val):mVal(val)
{
}
operator int()
{
return mVal;
}
int getVal()
{
return mVal;
}
private:
int mVal;
};
int main()
{
Integer t(42);
int x = (int)t; //We're turning the Integer into an int? Kinda makes sense.
std::cout << x << std::endl;
x = t.getVal(); //hey! we're getting the integer's value! Do I need this comment?
std::cout << x << std::endl;
}

InformationsquelleAutor user4581301

1
```
class example2;
class example1(){
operator example2()
{
example2 temp;
//more stuff
}
};
```
À ce point dans le temps dans le code la définition complète de example2 doit être connu du compilateur parce que vous êtes la création d'une instance de cette classe appelée temp. Cependant vous n'avez que transmet la déclaration de example2 à ce point dans le temps. Ainsi, alors que le compilateur sait que example2 est un type en raison de l'transmet une déclaration qu'il n'a pas le plein d'informations sur la classe à ce point dans le temps donc il est incapable de faire temp. C'est de vous donner l'erreur que vous voyez.

Si ce que vous voulez faire ici est d'être en mesure d'attribuer à example2s de types de example1s, vous devez créer un opérateur d'affectation pour example2 qui prend example1s.
```
class example2{
example2& operator= (example1 const& e1){
this->id = e1.id;
this->value = e1.numbers * e1.cost;
return *this;
}
};
```
Cependant ce qui me frappe comme une mauvaise conception, il y a probablement de meilleures façons d'obtenir ce que vous voulez qui implique une conception différente. Par exemple, une méthode qui a pour objet de prendre un example1 comme un paramètre et modifier l'état serait beaucoup plus clair. Que serait tout simplement la construction d'une nouvelle example2 de l'information dans la example1
- alors, comment puis-je utiliser l'opérateur exemple2()' membre de la méthode pour convertir exemple1 données dans exemple2 type de données.
- devrais-je utiliser le concept d'héritage?
- la navette Vous n'avez qu'à l'aide de l'opérateur d'assignation à partir de la copie tha données de exemple1 à exemple2 que j'ai fait et je l'ai déjà mentionné que j'ai résolu mon problème en utilisant exemple2(exemple1 e) { id=e.getid(); valeur=e.getnumber()*e.getcost(); } je veux de exemple1 classe à l'aide d'une classe à l'opérateur de ne pas l'opérateur d'assignation.
- Ce que j'ai suggéré ici est la surcharge de l'opérateur d'affectation, ce que vous avez fait était de faire une conversion. La première partie de la réponse explique comment résoudre le problème avec votre constructeur qui fait la conversion, assurez-vous que l'ensemble de la classe est définie en avant de ce point, vous avez besoin de plus que juste une déclaration de l'avant.
- si je suis la définition de exemple2 classe avant exemple1. il donne toujours l'erreur.pouvez-vous me donner la solution de conversion.Tout ce que vous voulez dire, merci de m'aider à écrire la conception pour que
InformationsquelleAutor shuttle87
0

Vous devez utiliser le type de retour exemple2 ensuite, il sera
- des fonctions ou de la méthode devrait être de retour exemple2? pourriez-vous donner plus de détails?
- veuillez fournir une explication détaillée.
InformationsquelleAutor Gspandey

juste a bien fonctionné, permettez-moi de savoir si je suis absent quelque chose..

je pense que vous avez été absent sont:

définition de la classe exemple2 avant la classe exemple1

2.accéder aux données privées des membres de exemple2 à travers le retour par referece

3.constructeur vide dans la classe de destination exemple2

    #include<iostream>
using namespace std;
class example2
{
int id;
int value;
public:
example2 () {}
example2(int x,int y){
id=x;
value=y;
}
void display(){
cout<<"id "<<id<<endl;
cout<<"value "<<value<<endl;
}
int& getid () //return by reference
{
return id;
}
int& getvalue () //return by reference
{
return value;
}
};
class example1
{
int id;
int numbers;
int cost;
public:
example1(int a, int b, int c)
{
id=a;
numbers=b;
cost=c;
}
operator example2()
{
example2 temp;
temp.getid()=id;
temp.getvalue()=numbers*cost;
return temp;
}
};
int main()
{
example1 s1(100,5,140.0);
example2 s2;
s2=s1;
s2.display();
return 0;
}

InformationsquelleAutor Suraj Oberai

Vous devez vous connecter pour publier un commentaire.