Fehler: Anruf von überlastet ist mehrdeutig

Question

bool find_solutions(const string if_need_all, vector< vector<char> > table, vector<int> ships, int row[], int col[]){ 
    sort(ships.begin(), ships.end(), greater<int>());//sort the ship length in descending order 
    static int counter = 0; //counter that tracks if the ship is to be placed vertically or horizontally 
    static int s = 0; //index of ship using 
    int fill;//ship to fill 
    int filling;//keep track how much the ship has been filled 
    if(s == ships.size()) return true; 
    for(unsigned int i = 0; i<table.size(); ++i){ 
    filling = 0; 
    fill = ships[s]; 
    for(unsigned int j = 0; j<table[i].size(); ++j){ 
     if(counter == 0 && insertable(table,row,col,i,j,counter,fill)){ 
     while(filling<fill){ 
      table[i][j+filling] = fill; 
      col[j+filling]--; 
      filling++; 
     } 
     row[i] -= fill; s++; 
     find_solutions(if_need_all, table, ships, row,col); 
     } 
     else{ 
     counter++; 
     } 
     if(counter == 1 && insertable(table,row,col,i,j,counter,fill)){ 
     while(filling<fill){ 
      table[i+filling][j] = fill; 
      row[i+filling]--; 
      filling++; 
     } 
     col[j] -= fill; s++; 
     find_solutions(if_need_all, table, ships, row, col); 
     } 
     else{ 
     counter--; 
     } 
    } 
    } 
    if(s != ships.size()) return false; 
    else return true; 
} 
main.cpp: In function ‘bool find_solutions(std::__cxx11::string,  std::vector<std::vector<char> >, std::vector<int>, int*, int*)’: 
main.cpp:277:67: error: call of overloaded  ‘insertable(std::vector<std::vector<char> >&, int*&, int*&, unsigned int&, unsigned int&, int&, int&)’ is ambiguous 
     if(counter == 0 && insertable(table,row,col,i,j,counter,fill)){ 
                  ^
main.cpp:13:6: note: candidate: bool insertable(const  std::vector<std::vector<char> >&, const int*, const int*, int, int, int, int) 
bool insertable(const vector< vector<char> >& inboard, const int r[], const int c[], 
    ^
main.cpp:125:6: note: candidate: bool insertable(std::vector<std::vector<char> >, const int*, const int*, int, int, int, int) 
bool insertable(const vector< vector<char> > inboard,const int r[], const int c[],co 
    ^

kann mir jemand sagen, welchen Fehler ich gemacht habe? Ich suchte online, dass Websites sagt, es ist entweder Variable erstellt mehrere Male oder Funktionsname bereits in der STL-Bibliothek vorhanden. Ich habe beide Bedingungen überprüft und sie gelten nicht für mein Problem. Ist es das Füllen, das Problem oder andere Variable verursacht, oder ist es die Funktion?

Answer 1

Sie haben insertable() mit den folgenden Parametertypen überlastet.

bool insertable(const std::vector<std::vector<char> >&, 
       const int*, const int*, int, int, int, int) 

bool insertable(std::vector<std::vector<char> >, 
       const int*, const int*, int, int, int, int) 

Nehmen wir an, T als

typedef std::vector<std::vector<char> > T; 

Der erste Parameter in beiden Methodendefinition eindeutig ist, da beide Methoden Typen T und T& als ersten Parameter annehmen können, so dass der Compiler kann nicht entscheiden, welche überlastet Methode zum Aufrufen. Übrigens sollten Sie keine überladenen Methoden erstellen, die sich in reference unterscheiden, stattdessen sollten Sie einen ganz anderen Typ verwenden. Weil ein Typ und seine Referenz immer kompatibel sind und daher als gleich betrachtet werden.

Für z. int und int& sind kompatibel, so insertable(int a) und insertable(int& b) sind gleich. Wenn Sie diese Methode wie folgt aufrufen, kann der Compiler nicht entscheiden, welche Methode aufgerufen werden soll.

int x = 20; 
insertable(x); 

In gleicher Weise sind unter Definitionen auch gleich, wenn Sie nicht const T in Funktionsaufruf verwendet.

bool insertable(const T&, const int*, const int*, int, int, int, int) 

bool insertable(T, const int*, const int*, int, int, int, int) 

@M.M in den Kommentaren:

T und const T& sind immer eindeutig. Jedoch sind T und T& nicht mehrdeutig, wenn das Argument ein rvalue ist. Die rvalue kann nicht an T& binden, und es ist ein gültiger Anwendungsfall gesondert zu überlasten für rvalues ​​ als lvalues ​​