दिलचस्प पोस्ट
जावा प्रॉपर्टी UTF-8 एन्कोडिंग इन एक्लिप्स सी में वैरिएबल घोषणा प्लेसमेंट jqgrid गतिशील कॉलम और डेटा JSON द्वारा स्काला की इस टाइपिंग, अमूर्त प्रकार आदि का उपयोग स्व-प्रकार को लागू करने के लिए कैसे करें? अजगर में तार पर धूमिल मौजूदा एएसआईएन के साथ आइटम के लिए सही अमेज़ॅन मेगावाट का प्रवाह एंड्रॉइड में जेक्सिंग का उपयोग कैसे करें वसंत एनोटेशन @ वैल्यू के साथ गुण फ़ाइल और लोड से एक सूची पढ़ना सोप या वेब सेवाओं के लिए आराम? 100% की ऊंचाई के साथ पूर्ण स्क्रीन आइफ्रेम पॉइंटर घटाव भ्रम Windows XP समर्थन के साथ स्थिर एमएसवीवी रनटाइम का उपयोग करते हुए, VS2012 के तहत स्थिर रूप से क्यूटी 4.8 / 5.2 कैसे बना सकता है? कैसे MVVM में एक PasswordBox के साथ बाध्य करने के लिए जेएसएफ घटक के आईडी विशेषता में <ui: repeat var> के साथ EL का उपयोग कैसे करें सभी संभव सी # सरणी प्रारंभिक वाक्यविन्यास

सी ++ में यूआरएल में कोड / डीकोड करें

क्या कोई अच्छा सी ++ कोड जानता है जो यह करता है?

वेब के समाधान से एकत्रित समाधान "सी ++ में यूआरएल में कोड / डीकोड करें"

मुझे इस समस्या का एन्कोडिंग आधा दिन का सामना करना पड़ा। उपलब्ध विकल्पों से नाखुश, और इस सी नमूना कोड पर एक नज़र डालने के बाद, मैंने अपना स्वयं का सी + + url-encode फ़ंक्शन रोल करने का निर्णय लिया:

#include <cctype> #include <iomanip> #include <sstream> #include <string> using namespace std; string url_encode(const string &value) { ostringstream escaped; escaped.fill('0'); escaped << hex; for (string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) { string::value_type c = (*i); // Keep alphanumeric and other accepted characters intact if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') { escaped << c; continue; } // Any other characters are percent-encoded escaped << uppercase; escaped << '%' << setw(2) << int((unsigned char) c); escaped << nouppercase; } return escaped.str(); } 

डीकोड फ़ंक्शन के क्रियान्वयन को पाठक के लिए एक व्यायाम के रूप में छोड़ दिया जाता है। : पी

अपने प्रश्न का उत्तर दे रहा है …

libcurl में curl_easy_escape है

 string urlDecode(string &SRC) { string ret; char ch; int i, ii; for (i=0; i<SRC.length(); i++) { if (int(SRC[i])==37) { sscanf(SRC.substr(i+1,2).c_str(), "%x", &ii); ch=static_cast<char>(ii); ret+=ch; i=i+2; } else { ret+=SRC[i]; } } return (ret); } 

सबसे अच्छा नहीं है, लेकिन ठीक काम 😉

और स्रोत कोड …

http://www.codeguru.com/cpp/cpp/string/conversions/article.php/c12759

शरीर में कम से कम 30 वर्ण होने चाहिए

सीपीपी-नेटलिब में फ़ंक्शन हैं I

 namespace boost { namespace network { namespace uri { inline std::string decoded(const std::string &input); inline std::string encoded(const std::string &input); } } } 

वे यूआरएल स्ट्रिंगों को सांकेतिक शब्दों में बदलने और डिकोड करने की अनुमति देते हैं।

सीजीआईसीसी में यूआरएल सांकेतिक शब्दों में बदलना और डीकोड करना शामिल है। form_urlencode और form_urldecode

यूआरएल एन्कोडिंग / डिकोडिंग एल्गोरिथ्म यह मुश्किल नहीं है।

मैं विनिर्देश से शुरू होगा:

विकिपीडिया पर यूआरएल एन्कोडिंग

यदि आप प्री-पकाए गए कोड चाहते हैं, तो सिर्फ इंटरनेट खोजें:

http://www.google.it/search?hl=it&q=Encode+Decode+URLs+in+C%2B%2B&meta=

(हां, यह पता यूआरएल-एन्कोडेड है)

आम तौर पर '%' को चारों के इंट मान में जोड़ना तब काम नहीं करेगा जब एन्कोडिंग, मान हेक्स समकक्ष के लिए माना जाता है जैसे '/' है '% 2F' नहीं '% 47'

मुझे लगता है कि यह यूआरएल एन्कोडिंग और डिकोडिंग दोनों के लिए सबसे अच्छा और संक्षिप्त समाधान है (ज्यादा नहीं हैडर निर्भरता)

 string urlEncode(string str){ string new_str = ""; char c; int ic; const char* chars = str.c_str(); char bufHex[10]; int len = strlen(chars); for(int i=0;i<len;i++){ c = chars[i]; ic = c; // uncomment this if you want to encode spaces with + /*if (c==' ') new_str += '+'; else */if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') new_str += c; else { sprintf(bufHex,"%X",c); if(ic < 16) new_str += "%0"; else new_str += "%"; new_str += bufHex; } } return new_str; } string urlDecode(string str){ string ret; char ch; int i, ii, len = str.length(); for (i=0; i < len; i++){ if(str[i] != '%'){ if(str[i] == '+') ret += ' '; else ret += str[i]; }else{ sscanf(str.substr(i + 1, 2).c_str(), "%x", &ii); ch = static_cast<char>(ii); ret += ch; i = i + 2; } } return ret; } 

[नेक्रोमांसर मोड चालू]
इस सवाल पर ठोकर खाई जब तेज, आधुनिक, मंच स्वतंत्र और सुरुचिपूर्ण समाधान की तलाश में था उपर्युक्त किसी भी तरह की तरह नहीं, सीपीपी-नेटलिब विजेता होगा लेकिन इसमें "डिकोड" फ़ंक्शन में भयानक स्मृति भेद्यता है। तो मुझे बढ़ावा देने की आत्मा क्यू / कर्म समाधान के साथ आया।

 namespace bsq = boost::spirit::qi; namespace bk = boost::spirit::karma; bsq::int_parser<unsigned char, 16, 2, 2> hex_byte; template <typename InputIterator> struct unescaped_string : bsq::grammar<InputIterator, std::string(char const *)> { unescaped_string() : unescaped_string::base_type(unesc_str) { unesc_char.add("+", ' '); unesc_str = *(unesc_char | "%" >> hex_byte | bsq::char_); } bsq::rule<InputIterator, std::string(char const *)> unesc_str; bsq::symbols<char const, char const> unesc_char; }; template <typename OutputIterator> struct escaped_string : bk::grammar<OutputIterator, std::string(char const *)> { escaped_string() : escaped_string::base_type(esc_str) { esc_str = *(bk::char_("a-zA-Z0-9_.~-") | "%" << bk::right_align(2,0)[bk::hex]); } bk::rule<OutputIterator, std::string(char const *)> esc_str; }; 

निम्नलिखित के रूप में उपयोग:

 std::string unescape(const std::string &input) { std::string retVal; retVal.reserve(input.size()); typedef std::string::const_iterator iterator_type; char const *start = ""; iterator_type beg = input.begin(); iterator_type end = input.end(); unescaped_string<iterator_type> p; if (!bsq::parse(beg, end, p(start), retVal)) retVal = input; return retVal; } std::string escape(const std::string &input) { typedef std::back_insert_iterator<std::string> sink_type; std::string retVal; retVal.reserve(input.size() * 3); sink_type sink(retVal); char const *start = ""; escaped_string<sink_type> g; if (!bk::generate(sink, g(start), input)) retVal = input; return retVal; } 

[नेक्रोमांसर मोड बंद]

EDIT01: शून्य पैडिंग सामान को तय किया – हार्टमुट कैसर के लिए विशेष धन्यवाद
EDIT02: CoLiRu पर लाइव

Libcurl का उपयोग करने के लिए बिल की सिफारिश के लिए अनुवर्ती जोड़ना: महान सुझाव, और अद्यतन करने के लिए:
3 साल बाद, curl_escape फ़ंक्शन को बहिष्कृत किया जाता है, इसलिए भविष्य में उपयोग के लिए curl_easy_escape का उपयोग करना बेहतर है

एक एपीआई को एक Win32 c ++ एप में यूआरएल को डीकोड करने के लिए खोजते समय मुझे इस प्रश्न पर समाप्त हुआ। चूंकि प्रश्न विंडो को मानते हुए मंच को काफी स्पष्ट नहीं करता है, इसलिए कोई बुरी बात नहीं है

InternetCanonicalizeUrl विंडोज़ प्रोग्रामों के लिए एपीआई है I अधिक जानकारी यहां

  LPTSTR lpOutputBuffer = new TCHAR[1]; DWORD dwSize = 1; BOOL fRes = ::InternetCanonicalizeUrl(strUrl, lpOutputBuffer, &dwSize, ICU_DECODE | ICU_NO_ENCODE); DWORD dwError = ::GetLastError(); if (!fRes && dwError == ERROR_INSUFFICIENT_BUFFER) { delete lpOutputBuffer; lpOutputBuffer = new TCHAR[dwSize]; fRes = ::InternetCanonicalizeUrl(strUrl, lpOutputBuffer, &dwSize, ICU_DECODE | ICU_NO_ENCODE); if (fRes) { //lpOutputBuffer has decoded url } else { //failed to decode } if (lpOutputBuffer !=NULL) { delete [] lpOutputBuffer; lpOutputBuffer = NULL; } } else { //some other error OR the input string url is just 1 char and was successfully decoded } 

InternetCrackUrl ( यहां ) यह भी निर्दिष्ट करने के लिए झंडे हैं कि यूआरएल को डिकोड करना है या नहीं

एक्सपररोनी से प्रेरित होकर मैंने एक विकोडक लिखा था सूचक के लिए धन्यवाद

 #include <iostream> #include <sstream> #include <string> using namespace std; char from_hex(char ch) { return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10; } string url_decode(string text) { char h; ostringstream escaped; escaped.fill('0'); for (auto i = text.begin(), n = text.end(); i != n; ++i) { string::value_type c = (*i); if (c == '%') { if (i[1] && i[2]) { h = from_hex(i[1]) << 4 | from_hex(i[2]); escaped << h; i += 2; } } else if (c == '+') { escaped << ' '; } else { escaped << c; } } return escaped.str(); } int main(int argc, char** argv) { string msg = "J%C3%B8rn!"; cout << msg << endl; string decodemsg = url_decode(msg); cout << decodemsg << endl; return 0; } 

संपादित करें: अवांछित सीटीटीपी और आईओमैनिप में शामिल हैं।

मुझे यहां यूआरआई डीकोड / यूनिसेप नहीं मिला, जो कि 2 और 3 बाइट क्रम भी डीकोड करता है अपने स्वयं के उच्च निष्पादन संस्करण का योगदान करते हुए, कि पर-फ़्लाई सी स्ट्रिंग इनपुट को एक wstring में कनवर्ट करता है:

 #include <string> const char HEX2DEC[55] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1, -1,-1,-1,-1, -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,10,11,12, 13,14,15 }; #define __x2d__(s) HEX2DEC[*(s)-48] #define __x2d2__(s) __x2d__(s) << 4 | __x2d__(s+1) std::wstring decodeURI(const char * s) { unsigned char b; std::wstring ws; while (*s) { if (*s == '%') if ((b = __x2d2__(s + 1)) >= 0x80) { if (b >= 0xE0) { // three byte codepoint ws += ((b & 0b00001111) << 12) | ((__x2d2__(s + 4) & 0b00111111) << 6) | (__x2d2__(s + 7) & 0b00111111); s += 9; } else { // two byte codepoint ws += (__x2d2__(s + 4) & 0b00111111) | (b & 0b00000011) << 6; s += 6; } } else { // one byte codepoints ws += b; s += 3; } else { // no % ws += *s; s++; } } return ws; } 

विंडोज़ एपीआई में इस कार्य के लिए शेलवपी.ए.एल.एल. द्वारा यूआरएलएस्केप / यूआरयूउस्पेस्पेप का निर्यात किया गया है।

यह संस्करण शुद्ध सी है और वैकल्पिक रूप से संसाधन पथ को सामान्यीकृत कर सकता है। इसे सी ++ के साथ प्रयोग करना तुच्छ है:

 #include <string> #include <iostream> int main(int argc, char** argv) { const std::string src("/some.url/foo/../bar/%2e/"); std::cout << "src=\"" << src << "\"" << std::endl; // either do it the C++ conformant way: char* dst_buf = new char[src.size() + 1]; urldecode(dst_buf, src.c_str(), 1); std::string dst1(dst_buf); delete[] dst_buf; std::cout << "dst1=\"" << dst1 << "\"" << std::endl; // or in-place with the &[0] trick to skip the new/delete std::string dst2; dst2.resize(src.size() + 1); dst2.resize(urldecode(&dst2[0], src.c_str(), 1)); std::cout << "dst2=\"" << dst2 << "\"" << std::endl; } 

आउटपुट:

 src="/some.url/foo/../bar/%2e/" dst1="/some.url/bar/" dst2="/some.url/bar/" 

और वास्तविक कार्य:

 #include <stddef.h> #include <ctype.h> /** * decode a percent-encoded C string with optional path normalization * * The buffer pointed to by @dst must be at least strlen(@src) bytes. * Decoding stops at the first character from @src that decodes to null. * Path normalization will remove redundant slashes and slash+dot sequences, * as well as removing path components when slash+dot+dot is found. It will * keep the root slash (if one was present) and will stop normalization * at the first questionmark found (so query parameters won't be normalized). * * @param dst destination buffer * @param src source buffer * @param normalize perform path normalization if nonzero * @return number of valid characters in @dst * @author Johan Lindh <johan@linkdata.se> * @legalese BSD licensed (http://opensource.org/licenses/BSD-2-Clause) */ ptrdiff_t urldecode(char* dst, const char* src, int normalize) { char* org_dst = dst; int slash_dot_dot = 0; char ch, a, b; do { ch = *src++; if (ch == '%' && isxdigit(a = src[0]) && isxdigit(b = src[1])) { if (a < 'A') a -= '0'; else if(a < 'a') a -= 'A' - 10; else a -= 'a' - 10; if (b < 'A') b -= '0'; else if(b < 'a') b -= 'A' - 10; else b -= 'a' - 10; ch = 16 * a + b; src += 2; } if (normalize) { switch (ch) { case '/': if (slash_dot_dot < 3) { /* compress consecutive slashes and remove slash-dot */ dst -= slash_dot_dot; slash_dot_dot = 1; break; } /* fall-through */ case '?': /* at start of query, stop normalizing */ if (ch == '?') normalize = 0; /* fall-through */ case '\0': if (slash_dot_dot > 1) { /* remove trailing slash-dot-(dot) */ dst -= slash_dot_dot; /* remove parent directory if it was two dots */ if (slash_dot_dot == 3) while (dst > org_dst && *--dst != '/') /* empty body */; slash_dot_dot = (ch == '/') ? 1 : 0; /* keep the root slash if any */ if (!slash_dot_dot && dst == org_dst && *dst == '/') ++dst; } break; case '.': if (slash_dot_dot == 1 || slash_dot_dot == 2) { ++slash_dot_dot; break; } /* fall-through */ default: slash_dot_dot = 0; } } *dst++ = ch; } while(ch); return (dst - org_dst) - 1; } 

रसदार बिट्स

 #include <ctype.h> // isdigit, tolower from_hex(char ch) { return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10; } char to_hex(char code) { static char hex[] = "0123456789abcdef"; return hex[code & 15]; } 

नोट किया कि

 char d = from_hex(hex[0]) << 4 | from_hex(hex[1]); 

जैसे की

 // %7B = '{' char d = from_hex('7') << 4 | from_hex('B'); 

आप "g_uri_escape_string ()" फ़ंक्शन प्रदान किए गए glib.h का उपयोग कर सकते हैं। https://developer.gnome.org/glib/stable/glib-URI-Functions.html

 #include <stdio.h> #include <stdlib.h> #include <glib.h> int main() { char *uri = "http://www.example.com?hello world"; char *encoded_uri = NULL; //as per wiki (https://en.wikipedia.org/wiki/Percent-encoding) char *escape_char_str = "!*'();:@&=+$,/?#[]"; encoded_uri = g_uri_escape_string(uri, escape_char_str, TRUE); printf("[%s]\n", encoded_uri); free(encoded_uri); return 0; } 

इसके साथ संकलन करें:

 gcc encoding_URI.c `pkg-config --cflags --libs glib-2.0` 

एक अन्य समाधान फेसबुक की मूर्खता पुस्तकालय का उपयोग कर उपलब्ध है: folly::uriEscape और folly::uriUnescape

बूस्ट के बिना किसी प्रोजेक्ट में ऐसा करना था। इसलिए, अपना खुद का लेखन समाप्त हो गया। मैं इसे केवल GitHub पर डालूंगा: https://github.com/corporateshark/LUrlParser

 clParseURL URL = clParseURL::ParseURL( "https://name:pwd@github.com:80/path/res" ); if ( URL.IsValid() ) { cout << "Scheme : " << URL.m_Scheme << endl; cout << "Host : " << URL.m_Host << endl; cout << "Port : " << URL.m_Port << endl; cout << "Path : " << URL.m_Path << endl; cout << "Query : " << URL.m_Query << endl; cout << "Fragment : " << URL.m_Fragment << endl; cout << "User name : " << URL.m_UserName << endl; cout << "Password : " << URL.m_Password << endl; } 

मुझे पता है कि प्रश्न सी ++ पद्धति के लिए पूछता है, लेकिन उन लोगों के लिए जिनकी आवश्यकता हो सकती है, मैं स्ट्रिंग एन्कोड करने के लिए सादे सी में एक बहुत ही कम फ़ंक्शन के साथ आया था। यह एक नया स्ट्रिंग नहीं बना है, बल्कि यह मौजूदा एक को बदलता है, जिसका अर्थ है कि इसमें नए स्ट्रिंग को रखने के लिए पर्याप्त आकार होना चाहिए। रखने के लिए बहुत आसान है

 void urlEncode(char *string) { char charToEncode; int posToEncode; while (((posToEncode=strspn(string,"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.~"))!=0) &&(posToEncode<strlen(string))) { charToEncode=string[posToEncode]; memmove(string+posToEncode+3,string+posToEncode+1,strlen(string+posToEncode)); string[posToEncode]='%'; string[posToEncode+1]="0123456789ABCDEF"[charToEncode>>4]; string[posToEncode+2]="0123456789ABCDEF"[charToEncode&0xf]; string+=posToEncode+3; } }