Waarom is het succes van het programma afhankelijk van het feit dat een overbelaste aannemer wordt gedeclareerd?

Ik schrijf c ++ -programma. Dit is een studentenklas:

#include "Student.hpp"
#include "Home.hpp"
#include 

using namespace std;
/*
 * This is default constructor
 */
Student::Student(){

}
/*
 * This is copy constructor
 */
Student::Student(const Student& orig) {
   copy(orig);// invokes deep copy method
}
/*
 * This is a destructor
 */
Student::~Student() {
}

/*
 * This is operator = overloading method.
 * 
 * @param student. It is a reference to student class
 * @return Returns pointer to current class
 */
Student & Student::operator=(Student & student){
   if(this != &student){//checks if they are referencing the same class.          
      copy(student);
   }
   return *this;
}

/*
 * This is setter
 * 
 * @param x The random integer number
 */
void Student::setValue(int x){
   data = x;
}

/*
 * The getter.
 * 
 * @return Returns integer digit
 */
int Student::getValue(){
   return data; 
}

/*
 * The copy method. It makes a deep copy of a current class.
 * 
 * @param orig. It contains a reference to student class
 */
void Student::copy(const Student &orig){
    if(this != &orig){
   //makes a copy of data member
       data = orig.data;      

    }
}

This is snippet of main method:

Student * array = new Student[objectSize];
    cout << "\nOriginal array of Student type: "; 
    int i = 0; 
    for(int x = objectSize; x > 0; x--){
      array[i].setValue(x);

      cout << array[i] << " ";//prints the contents of original Student type array
       i++;
    }

    defaultObject.addition(array, objectSize);//invokes function to sort array of Student type

Dit is een headerbestand:

#include 

using namespace std;

#ifndef STUDENT_HPP
#define STUDENT_HPP

class Student {

    friend ostream& operator<< (ostream& os, const Student& study){// overloads << operator for Student class      
        os << study.data;//the data you output       
    return os; 
   }
public:  
    Student();//default constructor
  //Student(int data);// overloaded constructor
    Student(const Student& orig);// copy constructor
    virtual ~Student();// destructor
    Student & operator=(Student& student);//overloads = operator
    void setValue(int x);// setter
    int getValue();// getter
    void copy(const Student &orig);// copy method


    friend bool operator> (Student &first, Student &second){// overloads greater operator
       return first.data > second.data;
   }    

private:
    int data;// data member for storing Student's class contents
};

#endif  /* STUDENT_HPP */

Het probleem is dat wanneer ik deze regel Student (int data); in het headerbestand commentaar het programma deze fout gooit:

Student.hpp: In function `std::ostream& operator<<(std::ostream&, const Student&)':
In file included from Student.cpp:12:
Student.hpp:21: error: no match for 'operator<<' in 'os << study->Student::data'
Student.hpp:20: note: candidates are: std::ostream& operator<<(std::ostream&, const Student&)
make[2]: *** [build/Debug/Cygwin-Windows/Student.o] Error 1
make[1]: *** [.build-conf] Error 2
make: *** [.build-impl] Error 2

BUILD FAILED (exit value 2, total time: 4s)

In feite is de overbelaste constructor bij het bestand Student.cpp niet gedefinieerd, maar als er een verklaring is, werkt het programma op NetBeans, hoewel het op de Linux-terminal de genoemde fout genereert.

0
Dit is een korte versie.
toegevoegd de auteur ucas, de bron
Er is een korte versie van de hoofdmethode (hoofdgedeelte) gegeven.
toegevoegd de auteur ucas, de bron
Ik ben bezig met het creëren van een reeks studententypes. Ik gebruik setter om de waarde door te geven aan de studentenklasse. Dan passeer ik die reeks studenten om het uit te zoeken. Kopieermethode is nodig om een ​​diepe kopie van een klas te maken.
toegevoegd de auteur ucas, de bron
Dit is mijn opdracht, ik heb een serie klassetype nodig, geef het vervolgens door aan de geïmplementeerde sorteermethode en sorteer de inhoud. En druk tenslotte de resultaten af.
toegevoegd de auteur ucas, de bron
@ucas: kort, maar niet op zichzelf staand. Waar is hoofd ?
toegevoegd de auteur ildjarn, de bron
Geef een kort, op zichzelf staand, correct voorbeeld op dat uw probleem vertoont. Maak het zo kort mogelijk.
toegevoegd de auteur Xeo, de bron
@ucas: Nee, dat is het niet. In uw code hoeft setValue , getValue , kopie , etc. niet aanwezig te zijn. Heb je die echt nodig om je probleem te tonen? Heeft u de lus in het hoofd nodig? Zou niet een eenvoudige Student zijn; std :: cout << s; volstaan?
toegevoegd de auteur Xeo, de bron
@ucas: Moet u dat doen om de compileerfout te activeren?
toegevoegd de auteur Xeo, de bron
¤ Momenteel komt de getoonde code niet overeen met de diagnose van de compiler. Reproduceer de fout in een klein programma en presenteer dat programma ongewijzigd . Een algemeen advies: (1) gebruik bij voorkeur std :: vector en andere standaardbibliotheekcontainers in plaats van ruwe arrays en aanwijzers; (2) druk de kopieerconstructie niet uit in termen van toewijzing, maar uitdrukkelijke opdracht in termen van kopieerconstructie (zoek het "verwissel-idioom" op); (3) als je het hebt over "deep copying" is de kans groot dat je een destructor nodig hebt (zoek de "regel van drie" op). Cheers & hth.,
toegevoegd de auteur Cheers and hth. - Alf, de bron
Kun je laten zien welke standaard headers je gebruikt?
toegevoegd de auteur curiousguy, de bron
@ucas - het probleem is dat het niet compileert als de constructor Student (int) ontbreekt. De vraag is echter, om dit probleem aan ons te tonen, moet je ons ook de setValue , getValue etc. laten zien? Ik vermoed niet.
toegevoegd de auteur Flexo, de bron

1 antwoord

error: no match for 'operator<<' in 'os << study->Student::data'
note: candidates are: std::ostream& operator<<(std::ostream&, const Student&)

U vraagt ​​het om een ​​int naar de stream te schrijven. Let op de zeer korte lijst van mogelijke kandidaten, de compiler zegt dat hij alleen weet hoe hij een student naar de stream moet schrijven. Dat was vroeger mogelijk voordat je de constructeur van de student (int) opmerkte. Die constructor kan worden gebruikt om een ​​int naar een student te converteren. Dat zal tijdens runtime een zeer slecht einde bereiken wanneer de stapel wordt opgeblazen, maar dat is niet belangrijk.

You are missing an #include for a header that declares an operator<< that allows an int to be written to the stream. Not actually sure which one that might be, I don't like streams. Not an issue, homework questions shouldn't have real answers :)

2
toegevoegd
Op NetBeans voor Windows werkt deze oplossing echter op de Linux-opdrachtregel en worden fouten gegenereerd 'Ongedefinieerde verwijzing naar Beoordeling :: Beoordeling ()'.
toegevoegd de auteur ucas, de bron
Het moet in staan, wat moet worden opgenomen als u std :: ostream wilt gebruiken (of misschien heeft hij inbegrepen, die net voorwaarts alle sjablonen declareert).
toegevoegd de auteur Xeo, de bron