Stringa amichevole del modello numerica in C ++

Nella libreria standard C ++ ci sono funzioni per convertire da stringhe a tipi numerici:

stoi
stol
stoll
stoul
stoull
stof
stod
stold

ma trovo noioso usarli nel codice modello. Perché non ci sono funzioni modello simili a:

template<typename T>
T sto(...)

convertire le stringhe in tipi numerici?

Non vedo alcun motivo tecnico per non averli, ma forse mi manca qualcosa. Possono essere specializzati per chiamare le funzioni nominate sottostanti e utilizzare enable_if/ conceptsper disabilitare tipi non numerici.

Esistono alternative compatibili con i modelli nella libreria standard per convertire le stringhe in tipi numerici e viceversa in modo efficiente?

Perché non ci sono funzioni modello simili a:

C ++ 17 ha tale stringa generica in funzione numerica, ma denominata diversamente. Sono andati con std::from_chars, che è sovraccarico per tutti i tipi numerici.

Come puoi vedere, il primo sovraccarico sta prendendo qualsiasi tipo intero come parametro di output e gli assegnerà il valore se possibile.

Può essere usato in questo modo:

template<typename Numeric>
void stuff(std::string_view s) {
    auto value = Numeric{};

    auto [ptr, error] = std::from_chars(s.data(), s.data() + s.size(), value);

    if (error) {
        // error with the conversion
    } else {
        // conversion successful, do stuff with value
    }
}

Come puoi vedere, può funzionare in un contesto generico.

Non è un modello e non funziona con le versioni locali ma se questo non è un blocco dello spettacolo, C ++ 17 ha già quello che vuoi: std::from_chars

Esistono sovraccarichi per tutti i tipi di numeri interi e in virgola mobile e l'interfaccia è la stessa ad eccezione degli ultimi parametri che sono diversi rispettivamente per i tipi di numeri interi e in virgola mobile (ma se il valore predefinito va bene non è necessario cambiare qualcosa). Poiché questa non è una funzione compatibile con le impostazioni locali, è anche abbastanza veloce. Batterà qualsiasi altra stringa per valutare la funzione di conversione e generalmente lo è per ordini di grandezza.

C'è un ottimo video CPPCON su <charconv>(l'intestazione from_charsvive) di Stephan T. Lavavej che puoi vedere sul suo utilizzo e sulle sue prestazioni qui: https://www.youtube.com/watch?v=4P_kbF0EbZM

Non guadagneresti molto perché in un'espressione simile

int x = sto("1");

Non esiste un modo (semplice) per dedurre il tipo desiderato per il parametro template. Dovresti scrivere

int x = sto<int>("1");

che in qualche misura sconfigge lo scopo di fornire una funzione generica. D'altra parte, a

template<typename T>
void sto(std::string x,T& t);

sarebbe utile come ti sei reso conto. In C ++ 17 c'è std::from_chars, che fa più o meno esattamente quello (non è un modello ma un insieme di sovraccarichi e prende puntatori ai caratteri anziché a una stringa, ma sono solo dettagli minori).

PS Non esiste un modo semplice per dedurre il tipo desiderato nell'espressione sopra, ma esiste un modo. Non penso che il nocciolo della tua domanda sia esattamente la firma che hai chiesto, e non credo che il seguente sia un buon modo per implementarlo, ma sapevo che esiste un modo per compilare la int x = sto("1");compilazione sopra ed ero curioso di vederlo in azione.

#include <iostream>
#include <string>

struct converter {
    const std::string& x;
    template <typename T> operator T() { return 0;}
};

template <> converter::operator int() { return stoi(x); }
template <> converter::operator double() { return stod(x); }
converter sto(const std::string& x) { return {x}; }

int main() {
    std::string s{"1.23"};
    int x = sto(s);
    double y = sto(s);
    std::cout << x << " " << y;
}

Funziona come previsto, ma ha gravi svantaggi, forse soprattutto consente di scrivere auto x = sto(s);, cioè è facile da usare in modo errato.

Una soluzione compatibile con tutti (anche i compilatori C ++ più vecchi come quelli C ++ - 98) è quella di utilizzare boost :: lexical_cast che è un modello per convertire tra tipi numerici e stringhe in entrambi i modi.

Esempio:

short myInt = boost::lexical_cast<short>(*argv);
std::string backToString = boost::lexical_cast<std::string>(myInt);

Vedi: https://www.boost.org/doc/libs/1_42_0/libs/conversion/lexical_cast.htm

Nelle versioni precedenti di C ++, stringstream è tuo amico. Se ho capito bene, allora quanto segue potrebbe essere interessante per te. È C ++ 11.

https://wandbox.org/permlink/nUNiUwWWTr7a0NXM

#include <sstream>
#include <string>
#include <iostream>

template<typename T, typename String>
T sto(const String & str) {
    T val;
    std::stringstream ss(str);
    ss >> val;
    return val;
}

template<typename T, typename String>
void sto(const String & str, T & val) {
    std::stringstream ss(str);
    ss >> val;
}

int main() {   
    std::cout << sto<float>("1.1") << ", " << sto<int>(std::string{"2"});

    // An alternative version that infers the type 
    double d;
    sto("3.3", d);
    std::cout << ", " << d;
}

Questo metodo funziona in C ++ 11 ed è piuttosto generale. Nella mia esperienza, questo metodo è robusto, ma non il più performante.