URLs in C ++ codieren / dekodieren

Stand ich vor der Codierung der Hälfte der dieses problem den anderen Tag. Unzufrieden mit der verfügbaren Optionen aus, und nachdem er einen Blick auf diese C-Beispielcodehabe ich beschlossen, roll meine eigenen C++ - url-encode-Funktion:

#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();
}

Die Umsetzung der decode-Funktion ist Links als übung für den Leser. 😛

InformationsquelleAutor der Antwort xperroni

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);
}

nicht die beste, aber funktioniert Prima 😉

InformationsquelleAutor der Antwort

cpp-Netzwerkbibliothek hat Funktionen

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

Sie ermöglichen das Kodieren und Dekodieren von URL-strings sehr einfach.

InformationsquelleAutor der Antwort Yuriy Petrovskiy

CGICC beinhaltet Methoden, um url-codieren und decodieren. form_urlencode und form_urldecode

InformationsquelleAutor der Antwort alanc10n

Url-Codierung/Decodierung Algorithmus ist nicht schwierig.

Ich würde anfangen aus der Spezifikation:

Die Url-Codierung auf Wikipedia

Wenn Sie möchten, vorgekocht code, nur die Suche im Internet:

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

(ja, die Adresse ist url-kodiert)

InformationsquelleAutor der Antwort Gabriele D'Antona

Hinzufügen, eine follow-up-Bill ' s Empfehlung für die Verwendung von libcurl: toller Vorschlag, und zu aktualisiert werden:

nach 3 Jahren, die curl_escape Funktion ist veraltet, so dass für die zukünftige Verwendung, es ist besser curl_easy_escape.

InformationsquelleAutor der Antwort Bagelzone Ha'bonè

Konnte ich nicht finden, eine URI-decode/unescape hier, dass auch decodiert 2-und 3-byte-Sequenzen. Mein Beitrag eigenen high-performance-version, die on-the-fly konvertiert die c-sting-Eingang auf einen 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;
}

InformationsquelleAutor der Antwort jamacoe

Diese version ist rein C und kann Optional normalisieren die Ressource Weg. Mit C++ ist trivial:

#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;
}

Ausgänge:

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

Und die eigentliche Funktion:

#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 <[email protected]>
 * @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;
}

InformationsquelleAutor der Antwort Johan

Können Sie "g_uri_escape_string ()" - Funktion zur Verfügung gestellt 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;
}

kompilieren mit:

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

InformationsquelleAutor der Antwort Vineet Mimrot

können Sie einfach die use-Funktion AtlEscapeUrl() von atlutil.h,, gehen Sie einfach durch die Dokumentation auf, wie es zu benutzen.

InformationsquelleAutor der Antwort Pratik

Ich weiß, die Frage bittet um eine C++ - Methode, aber für diejenigen, die es mal brauchen könnte, kam ich auf eine sehr kurze Funktion in plain C zu kodierenden Zeichenfolge. Sie nicht erstellen Sie einen neuen string, sondern es verändert das bestehende, was bedeutet, dass es müssen genügend Größe, um halten Sie die neue Zeichenfolge. Sehr einfach zu halten.

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;
    }
}

InformationsquelleAutor der Antwort Alfredo Meraz