funzione di confronto nel limite inferiore

Question

Ho seguente struttura

enum quality { good = 0, bad, uncertain }; 

    struct Value { 
     int time; 
     int value; 
     quality qual; 
    }; 

    class MyClass { 

public: 
    MyClass() { 
     InsertValues(); 
    } 

     void InsertValues(); 

     int GetLocationForTime(int time); 

private: 

    vector<Value> valueContainer; 
}; 

void MyClass::InsertValues() { 
    for(int num = 0; num < 5; num++) { 
     Value temp; 
     temp.time = num; 
     temp.value = num+1; 
     temp.qual = num % 2; 
     valueContainer.push_back(temp); 
    } 
} 


int MyClass::GetLocationForTime(int time) 
{ 

    // How to use lower bound here. 
    return 0; 
} 

Nel codice di cui sopra mi è stato gettato con il lotto di errori di compilazione. Penso che sto sbagliando qui sono nuovo alla programmazione STL e puoi correggermi dov'è l'errore? È meglio fare questo?

Grazie!

Answer 1

Il predicato deve prendere due parametri e restituire bool.

Poiché la funzione è una funzione membro ha la firma sbagliata.

Inoltre, potrebbe essere necessario essere in grado di confrontare il valore in int, valore in valore, int in valore e int in int utilizzando il proprio functor.

struct CompareValueAndTime 
{ 
    bool operator()(const Value& v, int time) const 
    { 
     return v.time < time; 
    } 

    bool operator()(const Value& v1, const Value& v2) const 
    { 
     return v1.time < v2.time; 
    } 

    bool operator()(int time1, int time2) const 
    { 
     return time1 < time2; 
    } 

    bool operator()(int time, const Value& v) const 
    { 
     return time < v.time; 
    } 
}; 

Questo è piuttosto ingombrante, quindi cerchiamo di ridurlo:

struct CompareValueAndTime 
{ 
    int asTime(const Value& v) const // or static 
    { 
     return v.time; 
    } 

    int asTime(int t) const // or static 
    { 
     return t; 
    } 

    template< typename T1, typename T2 > 
    bool operator()(T1 const& t1, T2 const& t2) const 
    { 
     return asTime(t1) < asTime(t2); 
    } 
}; 

quindi:

std::lower_bound(valueContainer.begin(), valueContainer.end(), time, 
    CompareValueAndTime()); 

Ci sono un paio di altri errori anche, ad esempio nessun punto e virgola alla fine della dichiarazione della classe, oltre al fatto che i membri di una classe sono privati ​​per impostazione predefinita, il che rende l'intera classe privata in questo caso. Ti sei perso un public: prima del costruttore?

La funzione GetLocationForTime non restituisce un valore. È necessario prendere il risultato di lower_bound e sottrarre begin() da esso. La funzione dovrebbe anche essere const.

Se l'intenzione di questa chiamata è quella di inserire qui, considerare il fatto che l'inserimento nel mezzo di un vettore è un'operazione O (N) e quindi il vettore potrebbe essere il tipo di raccolta errato.

Si noti che l'algoritmo lower_bound funziona solo su raccolte preordinate. Se si vuole essere in grado di cercare su diversi membri, senza ricorrere continuamente, si vuole creare indici su questi campi, eventualmente utilizzando di spinta multi_index

Answer 2

class è la parola chiave e non "classe":

class MyClass { 

E il suo corpo dovrebbe essere seguita da virgola ;.
Ci possono essere altri errori, ma potrebbe essere necessario incollarli nella domanda per ulteriore aiuto.

Answer 3

Un errore è che il quarto argomento di lower_bound (compareValue nel codice) non può essere una funzione membro. Può essere un funtore o una funzione libera. Rendendolo una funzione gratuita che è un amico di MyClass sembra essere il più semplice nel tuo caso. Inoltre ti manca la parola chiave di ritorno.

class MyClass { 
    MyClass() { InsertValues(); } 
    void InsertValues(); 
    int GetLocationForTime(int time); 
    friend bool compareValue(const Value& lhs, const Value& rhs) 
    { 
     return lhs.time < rhs.time; 
    } 

Answer 4

Si desidera rendere compareValue() una funzione normale. Il modo in cui l'hai implementato adesso, ti serve un oggetto di tipo MyClass in giro. Il modo in cui std::lower_bound() proverà a chiamarlo, passerà solo in due argomenti, nessun oggetto aggiuntivo. Se si desidera realmente che la funzione sia membro, è possibile impostarla come membro static.

Detto questo, c'è una penalità di prestazioni per l'utilizzo diretto delle funzioni. Si potrebbe desiderare di avere il tipo di confronto con un operatore di call inline funzione:

struct MyClassComparator { 
    bool operator()(MyClass const& m0, MyClass const& m1) const { 
     return m0.time < m1.time; 
    } 
}; 

... e utilizzare MyClassComparator() come comparatore.

Answer 5

1. Class parola chiave deve partire dal basso c-class.
2. struct Value ha tipo sbagliato qualtiy invece di quality
3. io non vedo using namespace std di utilizzare tipi STL senza di essa.
4. vector<value> - tipo sbagliato value invece di Value
5. Ecc

Devi controllare in primo luogo prima di pubblicare qui con questi semplici errori credo. E il problema principale qui che la funzione di confronto non può essere un membro della classe. Usalo come funzione gratuita:

bool compareValue(const Value lhs, const int time) { 
    return lhs.time < time ; 
}