Kann Überladung << Operator in C++

Question

nicht aufrufen Ich habe mehrere Threads hier gelesen und denke, ich habe dies entsprechend eingerichtet. Ich glaube, das Problem ist, dass ich ein * benutze und ich habe die überladene < < Einrichtung irgendwie nicht richtig, dh - die Parameterdefinition ist falsch. Das Problem ist, kompiliert und läuft erfolgreich, so habe ich keine Ahnung, wo ich den Fehler mache.

Es tut mir wirklich leid, wenn dies zuvor beantwortet wurde, aber ich kann es nicht finden.

#include <iostream> 
#include <vector> 
#include <fstream> 
#include <string> 
#include <list> 
#include <exception> 

using namespace std; //Allows us to not prepend std:: to many things. 

template<class t> 
class HashingTable 
{ 
public: 
    HashingTable(); 
    HashingTable(int size); 
    void insert(const char *x); 

private: 
    int x = 0; 
    vector<list<const char *>> hashedLists; 
    int currentSize; 
    int hash(const char * key); 

friend std::ostream& operator << (std::ostream & os, const HashingTable<t>); 
}; 

template<class t> std::ostream& operator<< (ostream & os, const HashingTable<t> &ht) 
{ 
    const int listSize = ht.size(); 
    for (unsigned int i = 0; i < listSize; i++) 
    { 
     list<const char *> searchList = ht[i]; 
     for (std::list<const char *>::const_iterator si = std::next(searchList.begin(), listSizeLimit); si != searchList.end(); ++si)  //for each value in hashed list. 
      cout << *si << " "; 
    } 

    return os; 
}; 

template<class t> 
int HashingTable<t>::hash(const char * key) { 
    return key[0] - 'A'; 
}; 

template<class t> 
HashingTable<t>::HashingTable(int size) 
{ 
    hashedLists.resize(size); 
}; 

template<class t> 
HashingTable<t>::HashingTable() 
{ 
    hashedLists.resize(0); 
}; 

template<class t> 
void HashingTable<t>::insert(const char *x) { 
    //string tempStr(x); 
    unsigned int hashVal = hash(x); 

    if (hashedLists.size() < (hashVal + 1)) //if the number of lists in the current vector is less than the resize value then... 
     hashedLists.resize(hashVal + 1); //resize the hashedLists vector  

    list<const char *> iList = hashedLists[hashVal]; 
    if (std::find(iList.begin(), iList.end(), x) == iList.end()) 
    { 
     iList.push_back(x); 
     hashedLists[hashVal] = iList; 
    } 

    currentSize++; 
}; 


int main() /* A sample main program */ 
{ 
    HashingTable<char*>* mht; 
    char* Names[25] = { "AB", "AC", "AE", "AZ", 
     "BA","BM", "BJ", "BZ", 
     "CA", "CX", "CZ", "CZZ", 
     "EJ", "EP", "EF", "ES", 
     "QW", "QE", "QR", "QD", 
     "SA", "SD", "SF", "SS", "SJ" }; 
    int i; 
    mht = new HashingTable<char*>(0); 

    for (i = 0; i < 25; i++) 
     (*mht).insert(Names[i]); 
    cout << "Printing the hash table after inserting...." << endl; 
    cout << *mht; 
    cout << endl; 

    return 0; 
} 

Vielen Dank für einen Einblick.

Answer 1

In:

cout << (mht); 

Die klammerten unnötig mht vom Typ HashingTable<char*> *. Sie haben eine Überladung von operator<< bereitgestellt, die eine HashingTable<T> const& dauert. Diese sind nicht gleich, daher wird Ihre Überlastung nicht berücksichtigt.

Was Sie meinte, war:

cout << *mht; 

Answer 2

Ihr Freund Erklärung ziemlich nutzlos ist und sogar schädlich. Es passt nicht zum tatsächlichen Funktionskörper, so dass es nicht hilft, gefunden zu werden oder zusätzlichen Zugriff auf private Mitglieder zu geben, und es wird mit dem definierten Operator während der Überladungsauflösung konkurrieren.

Wenn der Freund ausgewählt wird, gibt der Compiler einen Aufruf an eine Funktion aus, die nie einen Körper besitzt, was Ihren ungelösten externen Fehler verursacht.

Diese Art von Friend-Deklaration deklariert eine Familie von Nicht-Vorlage Funktionen im umschließenden Namespace. Es gibt keine Syntax, um sie out-of-line zu definieren.

Entfernen Sie die Freundschaftsdeklaration. Oder verschieben Sie den Body inline. In diesem Fall sollten Sie auch den zweiten Parameter als const-Referenz und nicht als Kopie festlegen.

Wenn Sie beginnen, den Operator-Funktionskörper aufzurufen, den Sie geschrieben haben, erhalten Sie zusätzliche Fehler wie ht.size() nicht vorhanden. Gehen Sie nicht davon aus, dass diese Fehler bedeuten, dass die Verwendung des Operators falsch ist - sie bedeuten tatsächlich, dass Ihre Verwendung richtig ist, und der Compiler versucht nun, abhängige Namen im Operatorfunktionsbody aufzulösen.