È possibile scrivere una funzione per std :: string e std :: wstring?

Question

Ho appena scritto una semplice funzione di utilità per std :: string. Poi ho notato che la funzione sarebbe esattamente la stessa se lo std::string fosse un std::wstring o un std::u32string. È possibile utilizzare una funzione di modello qui? Non ho molta familiarità con i modelli, e std::string e std::wstring sono modelli stessi, il che potrebbe essere un problema.

template<class StdStringClass> 
inline void removeOuterWhitespace(StdStringClass & strInOut) 
{ 
    const unsigned int uiBegin = strInOut.find_first_not_of(" \t\n"); 

    if (uiBegin == StdStringClass::npos) 
    { 
    // the whole string is whitespace 
    strInOut.clear(); 
    return; 
    } 

    const unsigned int uiEnd = strInOut.find_last_not_of(" \t\n"); 
    strInOut = strInOut.substr(uiBegin, uiEnd - uiBegin + 1); 
} 

È un modo corretto per farlo? Ci sono insidie ​​con questa idea. Non sto parlando di questa funzione, ma del concetto generale di utilizzare una classe di modelli StdStringClass e di chiamare le solite funzioni std::string come trovare, sostituire, cancellare, ecc.

Answer 1

È una buona idea, ma vorrei creare il modello in cima di std::basic_string piuttosto che generale StdStringclass

template<class T> 
inline void removeOuterWhitespace(std::basic_string<T>& strInOut) 
{ 
    constexpr auto delim[] = {T(' '),T('\t'),T('\n'),T(0)}; 
    const auto uiBegin = strInOut.find_first_not_of(delim); 

    if (uiBegin == std::basic_string<T>::npos) 
    { 
    // the whole string is whitespace 
    strInOut.clear(); 
    return; 
    } 

    const auto uiEnd = strInOut.find_last_not_of(delim); 
    strInOut = strInOut.substr(uiBegin, uiEnd - uiBegin + 1); 
} 

vorrei anche fosso lo stile di MSDN "inout" notazione Favro per il nome più semplice come str. il programmatore si indovina che strè il risultato poiché viene passato come riferimento non const e la funzione restituisce void.

inoltre, ho cambiato unsigned int in auto. tutti i contenitori/stringhe C++ standard restituiscono size_t quando restituiscono gli indici. size_t potrebbe non essere unsigned int. auto corrisponde automaticamente al valore restituito corretto.

Answer 2

Supponendo che il modello funzioni come previsto (non controllato ... scusa), un'altra opzione sarebbe quella di avvolgere la funzione in classe e controllare quali tipi di classi di stringhe si desidera applicare alla funzione per l'utilizzo costruttori.

EDIT: aggiunto quadro illustrativi

EDIT2 uno che compila (almeno con vs2015) :-)

class StringType1; 
class StringTypeN; 

class str { 

    //template function 
    template<class StdStringClass> 
    inline void removeOuterWhitespace(StdStringClass & strInOut) 
    { 
     //. 
     //. 
     //. 
    } 

public: 
    //constructors 
    str(StringType1 &s1) { removeOuterWhitespace(s1); } 
    //. 
    //. 
    //. 
    str(StringTypeN &sN) { removeOuterWhitespace(sN); } 


}; 

int main() { 

    return 0; 
} 

Edit3 Prova di concetto

#include <iostream> 
class incr { 
    //template function 
    template<class incrementor> 
    inline void removeOuterWhitespace(incrementor & n) 
    { 
     n++; 
    } 
public: 
    //constructors 
    incr(int &n1) { removeOuterWhitespace(n1); } 
    incr(double &n1) { removeOuterWhitespace(n1); } 
    incr(float &n1) { removeOuterWhitespace(n1); } 
}; 

int main() { 
    int n1 = 1; 
    double n2 = 2; 
    float n3 = 3; 
    std::cout << n1 << "\t" << n2 << "\t" << n3 << std::endl; 
    auto test1 = incr(n1); 
    auto test2 = incr(n2); 
    auto test3 = incr(n3); 
    //all variables modified 
    std::cout << "all variables modified by constructing incr" << std::endl; 
    std::cout << n1 << "\t" << n2 << "\t" << n3 << std::endl; 
    return 0; 
}