C libcurl Ausgabe in eine Zeichenfolge

Question

Ich möchte das Ergebnis dieser Curl-Funktion in einer Variablen speichern, wie kann ich das tun?

#include <stdio.h> 
#include <curl/curl.h> 

int main(void) 
{ 
    CURL *curl; 
    CURLcode res; 

    curl = curl_easy_init(); 
    if(curl) { 
    curl_easy_setopt(curl, CURLOPT_URL, "curl.haxx.se"); 
    res = curl_easy_perform(curl); 

    /* always cleanup */ 
    curl_easy_cleanup(curl); 
    } 
    return 0; 
} 

danke, ich es wie folgt gelöst:

#include <stdio.h> 
#include <stdlib.h> 
#include <curl/curl.h> 

function_pt(void *ptr, size_t size, size_t nmemb, void *stream){ 
    printf("%d", atoi(ptr)); 
} 

int main(void) 
{ 
    CURL *curl; 
    CURLcode res; 
    curl = curl_easy_init(); 
    if(curl) { 
    curl_easy_setopt(curl, CURLOPT_URL, "curl.haxx.se"); 
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, function_pt); 
    curl_easy_perform(curl); 
    curl_easy_cleanup(curl); 
    } 
    system("pause"); 
    return 0; 
} 

Answer 1

Sie können eine Callback-Funktion einstellen, dass eingehende Datenblocks empfangen curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, myfunc);

Der Rückruf verwenden ein benutzerdefiniertes Argument, die Sie festlegen können mit curl_easy_setopt(curl, CURLOPT_WRITEDATA, p)

Hier ist ein Code-Snippet ist, die einen Puffer übergeben werden struct string {*ptr; len} zu die Callback-Funktion und erhöht diesen Puffer bei jedem Aufruf mit realloc().

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <curl/curl.h> 

struct string { 
    char *ptr; 
    size_t len; 
}; 

void init_string(struct string *s) { 
    s->len = 0; 
    s->ptr = malloc(s->len+1); 
    if (s->ptr == NULL) { 
    fprintf(stderr, "malloc() failed\n"); 
    exit(EXIT_FAILURE); 
    } 
    s->ptr[0] = '\0'; 
} 

size_t writefunc(void *ptr, size_t size, size_t nmemb, struct string *s) 
{ 
    size_t new_len = s->len + size*nmemb; 
    s->ptr = realloc(s->ptr, new_len+1); 
    if (s->ptr == NULL) { 
    fprintf(stderr, "realloc() failed\n"); 
    exit(EXIT_FAILURE); 
    } 
    memcpy(s->ptr+s->len, ptr, size*nmemb); 
    s->ptr[new_len] = '\0'; 
    s->len = new_len; 

    return size*nmemb; 
} 

int main(void) 
{ 
    CURL *curl; 
    CURLcode res; 

    curl = curl_easy_init(); 
    if(curl) { 
    struct string s; 
    init_string(&s); 

    curl_easy_setopt(curl, CURLOPT_URL, "curl.haxx.se"); 
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc); 
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s); 
    res = curl_easy_perform(curl); 

    printf("%s\n", s.ptr); 
    free(s.ptr); 

    /* always cleanup */ 
    curl_easy_cleanup(curl); 
    } 
    return 0; 
} 

Answer 2

aus dem Handbuch hier lesen: http://curl.haxx.se/libcurl/c/curl_easy_setopt.html Ich glaube, Sie mehrere Anrufe müssen die erste ist die URL, die Sie bearbeiten möchten, curl_setopt, die zweite sein so etwas wie:

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, function_ptr); 

Wo function_ptr diese Signatur übereinstimmt:

size_t function(void *ptr, size_t size, size_t nmemb, void *stream) 

Was passiert hier ist, bezeichnen Sie eine Callback-Funktion, die libcurl aufrufen wird, wenn es über eine Ausgabe verfügt, die Sie von der von Ihnen aufgerufenen Übertragung schreiben können. Sie können ihn automatisch in eine Datei schreiben lassen oder ihm einen Zeiger auf eine Funktion übergeben, die die Ausgabe selbst übernimmt. Mit dieser Funktion sollten Sie in der Lage sein, die verschiedenen Ausgangs-Strings in einem Stück zusammenzusetzen und sie dann in Ihrem Programm zu verwenden.

Ich bin mir nicht sicher, welche anderen Optionen Sie möglicherweise festlegen/was sonst wirkt sich auf Ihre App verhalten, so haben Sie einen guten Blick durch diese Seite.

Answer 3

Die folgende Antwort ist die C++ Art und Weise, es zu tun, mit std::string, statt nullterminierten String. Es verwendet immer noch eine Callback-Funktion (es gibt keinen Weg um es herum), aber behandelt auch Zuteilungsfehler mit Try/Catch.