C++ tableau de tri par variable privée

Question

J'ai cette classe

Class VehicleTwoD 
{ 
private: 
doubleArea; 
} 

donc je veux trier par doubleArea;

à mon main.cpp

J'obtenu

int main() 
{ 
VehicleTwoD *vehicletwod[100]; 
sort(vehicletwod[0], vehicletwod[vehicleCounter]); 

for (int i=0;i<vehicleCounter;vehicleCounter++) 
    { 
cout << "Vehicle " << i << end; 
cout << vehicletwod[i]->toDisplay() << endl; 
    } 
} 

Below is my operator overload at Vehicle.h 


bool VehicleTwoD::operator<(const VehicleTwoD& rhs) const 
{ 
return area > rhs.area; 
} 

Lorsque je tente exécuter le programme, je reçois erreur d'exécution - Segmentation faute de vidage de base.

En supposant que mon compteur du véhicule est mal et mon Vehicletwod a obtenu au moins 2 objet lorsque je tente cours toDisplay, ce qui est en fait a mal tourné ..

Mise à jour:

Je viens de faire cela grâce à la commentaires précieux que je reçois des experts ici.

à main.cpp

int main() 
{ 
VehicleTwoD *vehicletwod[100]; 

for(int i=0;i<100;i++) 
{ 
vehicletwod[i] = new VehicleTWoD(); 
} 

//some computation then I go to sort.. 

sort(&vehicletwod[0],&vehicletwod[vehicleCounter]); 

for(int i=0;i<vehicleCounter;i++) 
{ 
cout << vehicletwod->toDisplay() << endl; 
} 

} 

La sortie restent les mêmes, rien trié .. Je ne sais pas pourquoi ..

c'est l'opérateur booléen je l'ai fait au VehicleTwoD.h

VehicleTwoD.h

public: 
bool operator<(const VehicleTwoD&) const; 

VehicleTwoD.cpp

bool VehicleTwoD::operator<(const VehicleTwoD& rhs) const 
{ 
return area > rhs.area; 
} 

Rien est trié .. J'espère au moins ce genre soit décroissant ou croissant ..

j'étais étonnant s'il y a une manière que je peux affecter mon tableau de VehicleTwoD dans un appel vecteur sortVector, car après trier en croissant, je veux trier en descendant aussi. Donc une fonction inverse dans le vecteur sera bonne pour le résoudre.

Une suggestion? Merci à tous les experts utiles et gentils ici !!

Answer 1

VehicleTwoD *vehicletwod[100]; 

Cela crée simplement un tableau de références qui pointent vers un emplacement de mémoire non valide.

Vous avez besoin d'une boucle ou d'un autre moyen pour allouer 100 références valides. Exemple:

for(int i=0;i < 100;i++) 
{ 
    vehicletwod[i] = new VehicleTwoD() ; 
} 

Et vous devez vous souvenir de libérer ces mémoires.

Answer 2

Eh bien, vehicletwod[i]->toDisplay() est UB car vehicletwod[i] (quel que soit i est) n'est jamais initialisé.

VehicleTwoD *vehicletwod[100]; crée simplement un tableau de 100 pointeurs pendants.

Je vous suggère d'utiliser un std::vector<std::unique_ptr<VehicleTwoD>> à la place (puisqu'il semble que votre classe est polymorphe et que vous voulez un comportement polymorphe).

Answer 3

Il y a beaucoup de choses qui ne vont pas dans votre programme.

VehicleTwoD *vehicletwod[100]; 

crée un tableau de pointeurs 100 non initialisées à VehicleTwoD

sort(vehicletwod[0], vehicletwod[vehicleCounter]); 

trie la plage définie par deux pointeurs, vehicletwod[0] et vehicletwod[vehicleCounter]. Comme le tableau n'est pas initialisé, ces pointeurs sont corrompus, donc le tri corromprait la mémoire.

Vous voudrez peut-être les suivantes

std::vector<VehicleTwoD> vehicletwod; // vector of instances 
// initialize the vector 
// ... 
sort(vehicletwod.begin(), vehicletwod.end()); 

Answer 4

Pour ajouter à ce que les autres ont dit, voici un exemple compilable (mise à jour pour le tri inverse/mise à jour pour la classe statique fonction de comparaison):

Au lieu de surcharger le < Opérateur, vous pouvez envisager de rendre le type direction explicite, par exemple en spécifiant des comparateurs statiques comme indiqué ci-dessous. Je préfère cette option car elle vous permet de documenter votre intention.

dans Vehicle.h:

#include <random> 
class VehicleTwoD 
{ 

    private: 
     double area; 
    public: 
     VehicleTwoD() 
     { 
      area = ((double)rand()/(double)RAND_MAX); 
     } 

     double toDisplay() 
     { 
      return area; 
     } 

     bool VehicleTwoD::operator<(const VehicleTwoD& rhs) const 
     { 
      return area > rhs.area; 
     } 
     static bool VehicleTwoD::greater(const VehicleTwoD &lhs, const VehicleTwoD &rhs) 
     { 
      return lhs.area > rhs.area; 
     } 

     static bool VehicleTwoD::lesser(const VehicleTwoD &lhs, const VehicleTwoD &rhs) 
     { 
      return lhs.area < rhs.area; 
     } 

}; 

et main.cpp:

#include "Vehicle.h"  
#include <vector> 
#include <time.h> 
#include <algorithm> 
#include <iostream> 


int main() 
{ 

    srand((unsigned)time(NULL)); 
    std::vector<VehicleTwoD> vehicles(100); 
    std::vector<VehicleTwoD>::iterator it; 


    sort(vehicles.begin(), vehicles.end()); 
    for(it = vehicles.begin(); it != vehicles.end(); it++) 
    { 
     std::cout << "Vehicle area -> " << it->toDisplay() << std::endl; 
    } 
    std::cout << "Press any key..." << std::endl; 
    std::cin.get(); 

    // reverse sort - note that rbegin() rend() may be second-class citizens 
    // depending on your compiler's implementation and that their use may therefore 
    // be limited 
    sort(vehicles.rbegin(), vehicles.rend()); 
    for(it = vehicles.begin(); it != vehicles.end(); it++) 
    { 
     std::cout << "Vehicle area -> " << it->toDisplay() << std::endl; 
    } 
    std::cout << "Press any key..." << std::endl; 
    std::cin.get(); 

    // or (document your intention) 
    sort(vehicles.begin(), vehicles.end(), VehicleTwoD::greater); 
    for(it = vehicles.begin(); it != vehicles.end(); it++) 
    { 
     std::cout << "Vehicle area -> " << it->toDisplay() << std::endl; 
    } 
    std::cout << "Press any key..." << std::endl; 
    std::cin.get(); 

    sort(vehicles.begin(), vehicles.end(), VehicleTwoD::lesser); 
    for(it = vehicles.begin(); it != vehicles.end(); it++) 
    { 
     std::cout << "Vehicle area -> " << it->toDisplay() << std::endl; 
    } 
    std::cout << "Press any key..." << std::endl; 
    vehicles.clear(); 
    std::cin.get(); 
    return 0; 

}