Comparar versiones como cadenas

Question

Comparar números de versión como cadenas no es tan fácil ...
"1.0.0.9"> "1.0.0.10", pero no es correcto.
La forma obvia de hacerlo correctamente es analizar estas cadenas, convertir a números y compararlos como números. ¿Hay alguna otra manera de hacerlo más "elegantemente"? Por ejemplo, boost :: string_algo ...

Answer 1

No veo lo que podría ser más elegante que el análisis, pero por favor hacer uso de las instalaciones de biblioteca estándar ya instaladas. Suponiendo que no es necesario la comprobación de errores:

void Parse(int result[4], const std::string& input) 
{ 
    std::istringstream parser(input); 
    parser >> result[0]; 
    for(int idx = 1; idx < 4; idx++) 
    { 
     parser.get(); //Skip period 
     parser >> result[idx]; 
    } 
} 

bool LessThanVersion(const std::string& a,const std::string& b) 
{ 
    int parsedA[4], parsedB[4]; 
    Parse(parsedA, a); 
    Parse(parsedB, b); 
    return std::lexicographical_compare(parsedA, parsedA + 4, parsedB, parsedB + 4); 
} 

algo más complicado va a ser más difícil de mantener y no es digno de su tiempo.

Answer 2

me gustaría crear una clase de versión.
Luego es simple definir el operador de comparación para la clase de versión.

#include <iostream> 
#include <sstream> 
#include <vector> 
#include <iterator> 

class Version 
{ 
    // An internal utility structure just used to make the std::copy in the constructor easy to write. 
    struct VersionDigit 
    { 
     int value; 
     operator int() const {return value;} 
    }; 
    friend std::istream& operator>>(std::istream& str, Version::VersionDigit& digit); 
    public: 
     Version(std::string const& versionStr) 
     { 
      // To Make processing easier in VersionDigit prepend a '.' 
      std::stringstream versionStream(std::string(".") + versionStr); 

      // Copy all parts of the version number into the version Info vector. 
      std::copy( std::istream_iterator<VersionDigit>(versionStream), 
         std::istream_iterator<VersionDigit>(), 
         std::back_inserter(versionInfo) 
        ); 
     } 

     // Test if two version numbers are the same. 
     bool operator<(Version const& rhs) const 
     { 
      return std::lexicographical_compare(versionInfo.begin(), versionInfo.end(), rhs.versionInfo.begin(), rhs.versionInfo.end()); 
     } 

    private: 
     std::vector<int> versionInfo; 
}; 

// Read a single digit from the version. 
std::istream& operator>>(std::istream& str, Version::VersionDigit& digit) 
{ 
    str.get(); 
    str >> digit.value; 
    return str; 
} 


int main() 
{ 
    Version  v1("10.0.0.9"); 
    Version  v2("10.0.0.10"); 

    if (v1 < v2) 
    { 
     std::cout << "Version 1 Smaller\n"; 
    } 
    else 
    { 
     std::cout << "Fail\n"; 
    } 
} 

Answer 3

int VersionParser(char* version1, char* version2) { 

    int a1,b1, ret; 
    int a = strlen(version1); 
    int b = strlen(version2); 
    if (b>a) a=b; 
    for (int i=0;i<a;i++) { 
      a1 += version1[i]; 
      b1 += version2[i]; 
    } 
    if (b1>a1) ret = 1 ; // second version is fresher 
    else if (b1==a1) ret=-1; // versions is equal 
    else ret = 0; // first version is fresher 
    return ret; 
}