मैं स्ट्रिंग के रूप में प्रतिनिधित्व किए गए आईपी पते को कैसे बढ़ा सकता हूं?

Question

मैं चार तरह चार प्रकार में एक IP पता होना आईपी = "192.123.34.134" मैं अंतिम मान (134) को बढ़ा देते चाहते हैं। क्या मुझे किसी को यह कैसे करना चाहिए? मुझे लगता है, मुझे इसे एक पूर्णांक में परिवर्तित करना चाहिए, और फिर वापस, लेकिन दुर्भाग्य से मुझे नहीं पता कि कैसे? :(मैं सी का उपयोग कर रहा ++।

कृपया मेरी मदद करो!

धन्यवाद, kampi

Answer 1

आप एक पूर्णांक inet_addr का उपयोग कर के लिए एक स्ट्रिंग से आईपी पते परिवर्तित कर सकते हैं, तो फिर, यह जोड़ तोड़ के बाद, इसे वापस एक स्ट्रिंग के लिए कनवर्ट inet_ntoa साथ।

उनके उपयोग का तरीका बारे में अधिक जानकारी के लिए इन कार्यों के लिए the documentation देखें।

// NOTE: only works for IPv4. Check out inet_pton/inet_ntop for IPv6 support. 
char* increment_address(const char* address_string) 
{ 
    // convert the input IP address to an integer 
    in_addr_t address = inet_addr(address_string); 

    // add one to the value (making sure to get the correct byte orders) 
    address = ntohl(address); 
    address += 1; 
    address = htonl(address); 

    // pack the address into the struct inet_ntoa expects 
    struct in_addr address_struct; 
    address_struct.s_addr = address; 

    // convert back to a string 
    return inet_ntoa(address_struct); 
} 

* nix सिस्टम पर <arpa/inet.h>, या <winsock2.h> विंडोज पर शामिल करें:

यहां एक छोटा समारोह है कि तुम क्या चाहते हो जाएगा।

Answer 2

मैं एक विधि है कि उस प्रारूप में एक स्ट्रिंग को स्वीकार करता है लिखते थे।
4 पूर्णांक के लिए इसे बदलें। वेतन वृद्धि। (महत्वपूर्ण चेक रेंज)
तो फिर तुम somthing अधिक लंबे समय तक और मजबूत एक वर्ग आईपी पते का प्रतिनिधित्व चाहते हैं एक स्ट्रिंग के लिए वापस परिवर्तित।

। तो फिर तुम वर्ग को बनाए रखने के लिए एक के रूप में appropraite में हेरफेर और स्ट्रिंग के लिए कनवर्ट जब जरूरत।

#include <iostream> 
#include <istream> 
#include <sstream> 
#include <string> 
#include <stdexcept> 



class MyIp 
{ 
    struct Dot 
    {}; 
    struct Byte 
    { 
     Byte(unsigned char& val) 
      :m_val(val) 
     {} 
     unsigned char& m_val; 
    }; 
    friend std::istream& operator>>(std::istream& str,MyIp::Dot const& d); 
    friend std::istream& operator>>(std::istream& str,MyIp::Byte const& b); 
    friend std::ostream& operator<<(std::ostream& str,MyIp const& ip); 
    public: 
     MyIp(std::string const& ip) 
     { 
      std::stringstream str(ip); 
      str >> Byte(ad[0]) >> Dot() >> Byte(ad[1]) >> Dot() >> Byte(ad[2]) >> Dot() >> Byte(ad[3]); 
      std::string leftover; 
      if (str >> leftover) 
      { throw std::runtime_error("InvalidIP: Long"); 
      } 
     } 
     void inc(int index) 
     { 
      if ((index >= 0) && (index <=3)) 
      { 
       ++ad[index]; 
       if (ad[index] == 0) 
       { 
        inc(index-1); 
       } 
      } 
     } 
    private: 
     unsigned char ad[4]; 
}; 
std::istream& operator>>(std::istream& str,MyIp::Dot const& d) 
{ 
    char x = str.get(); 
    if (x != '.') 
    { throw std::runtime_error("Invalid IP: Dot"); 
    } 
    return str; 
} 
std::istream& operator>>(std::istream& str,MyIp::Byte const& b) 
{ 
    unsigned int val; 
    str >> val; 
    if (!str || val > 255) 
    { throw std::runtime_error("Invalid IP: Val"); 
    } 
    b.m_val = static_cast<unsigned char>(val); 
    return str; 
} 
std::ostream& operator<<(std::ostream& str,MyIp const& ip) 
{ 
    return str << static_cast<unsigned int>(ip.ad[0]) 
       << "." << static_cast<unsigned int>(ip.ad[1]) 
       << "." << static_cast<unsigned int>(ip.ad[2]) 
       << "." << static_cast<unsigned int>(ip.ad[3]); 
} 

int main() 
{ 
    try 
    { 
     std::string ip("127.0.0.1"); 

     MyIp addr(ip); 

     std::cout << addr << "\n"; 
     addr.inc(3); 
     std::cout << addr << "\n"; 
    } 
    catch(std::exception const& e) 
    { 
     std::cout << "What: " << e.what() << "\n"; 
    } 
} 

Answer 3

इस साइट में मेरी टैब खा लिया, तो मैं फिर से कोशिश करेंगे। मुझे यकीन है कि इस तरह कुछ करने के लिए एक पुस्तकालय है, लेकिन यह काम करना चाहिए (मेरा वाक्यविन्यास मानना ​​गड़बड़ नहीं है) विचार को पूरा करने के लिए पर्याप्त है।

छद्म कोड:

char[] ipAddress= "192.123.34.134"; 

if (ipAddress[ipAddress.Length-1] == '9') 
{ 
    if(ipAddress[ipAddress.Length-2]=='9') 
    { 
     ipAddress[ipAddress.Length-1]='0'; 
     ipAddress[ipAddress.Length-2]='0'; 
     ipAddress[ipAddress.Length-3]=(char)ipAddress[ipAddress.Length-3]+1; 
    } 
    else 
    { 
     ipAddress[ipAddress.Length-2]=(char)ipAddress[ipAddress.Length-2]+1; 
     ipAddress[ipAddress.Length-1]='0'; 
    } 
} 
else 
{ 
    ipAddress[ipAddress.Length-1]=(char)ipAddress[ipAddress.Length-1]+1; 
} 

Answer 4

त्वरित/गंदा!

void increment(std::string& ip) 
{ 
    std::string::size_type dot = ip.find_last_of('.'); 
    std::stringstream stream(ip.substr(dot+1)); 
    int part = 0; 

    stream >> part; 

    part++; 

    stream.str(""); stream.clear(); 

    stream << part; 

    ip.replace(dot+1, std::string::npos, stream.str()); 
} 

Answer 5

आप अंतिम "।" के स्थान का भी उपयोग कर सकते हैं। और अंत करने के लिए वहाँ से ले एक पूर्णांक में बदलने के लिए, इसे टक्कर 1, सीमाओं की जाँच करें और फिर इसे एक स्ट्रिंग में बदल जाएंगे और आधार हिस्से को जोड़ देते हैं।

Answer 6

यह शायद बहुत समझदार नहीं है, लेकिन इसके बारे में सोचने के लिए मजेदार था।

आईपी पते अंतरिक्ष के बाद से 32-बिट आप अहस्ताक्षरित 32-बिट पूर्णांक में आई पी पतों कन्वर्ट करने के लिए एक समारोह लिख सकता है। फिर आप 1 या जितना चाहें उतना जोड़ या घटा सकते हैं, और वापस आईपी पते में परिवर्तित कर सकते हैं। आपको रेंज जांच के बारे में चिंता करने की ज़रूरत नहीं है।

pseduo-कोड में 192.123.34.134 के लिए आपको बस इतना चाहते हैं:

int i = (192 << 24) + (123 << 16) + (34 << 8) + 134 

आम तौर पर, a.b.c. के लिएघ:

int i = (a << 24) + (b << 16) + (c << 8) + d 

अब i के रूप में ज्यादा बदलने के रूप में आप चाहते हैं (i++, i+=10000) और वापस परिवर्तित:

String ip = (i >> 24) + "." + 
      ((i >> 16) mod 256) + "." + 
      ((i >> 8) mod 256) + "." + 
      (i mod 256); 

कीजिए वाक्य रचना - मैं सी ++ अपने आप को बचाने के लिए नहीं लिख सका।

एमके

Answer 7

int a,b,c,d; 
sscanf(str, "%d.%d.%d.%d", &a,&b,&c,&d); 
sprintf(str, "%d.%d.%d.%d\0", a,b,c,d+1);