C libcurl obtenir une sortie dans une chaîne

Je veux stocker le résultat de ce roulage de la fonction dans une variable, comment puis-je le faire?

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

merci, je l'ai résolu comme ceci:

#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;
  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;
}
InformationsquelleAutor frx08 | 2010-02-24
  1. 100

    Vous pouvez définir une fonction de rappel pour recevoir les blocs de données à l'aide de curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, myfunc);

    Le rappel de prendre un définis par l'utilisateur argument que vous pouvez définir à l'aide curl_easy_setopt(curl, CURLOPT_WRITEDATA, p)

    Voici un extrait de code qui passe un tampon struct string {*ptr; len} à la fonction de rappel et augmente que de la mémoire tampon sur chaque appel à l'aide de 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;
}
    • Très bonne réponse. Je me suis tout de em dans la chaîne. Yipee!
    • Nice. Encore mieux si tous ceux size_t (en plus de len lui-même) serait déclaré const.
    • pour le C++ std::string aller ici
    InformationsquelleAutor Alex Jasmin
  2. 27

    La réponse suivante est le C++ façon de le faire, avec std::string, au lieu de null-terminated string. Il utilise toujours une fonction de rappel (il n'y a pas moyen de contourner cela), mais gère également la répartition de l'erreur à l'aide de try/catch.

    #include <iostream>
#include <string>
#include <curl/curl.h>
size_t CurlWrite_CallbackFunc_StdString(void *contents, size_t size, size_t nmemb, std::string *s)
{
size_t newLength = size*nmemb;
try
{
s->append((char*)contents, newLength);
}
catch(std::bad_alloc &e)
{
//handle memory problem
return 0;
}
return newLength;
}
int main()
{
CURL *curl;
CURLcode res;
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
std::string s;
if(curl)
{
curl_easy_setopt(curl, CURLOPT_URL, "curl.haxx.se");
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); //only for https
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); //only for https
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlWrite_CallbackFunc_StdString);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s);
curl_easy_setopt (curl, CURLOPT_VERBOSE, 1L); //remove this to disable verbose output
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
/* Check for errors */
if(res != CURLE_OK)
{
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
/* always cleanup */
curl_easy_cleanup(curl);
}
std::cout<<s<<std::endl;
std::cout<< "Program finished!" << std::endl;
}
    • A bien fonctionné pour moi. Facile et plus courte que les réponses ci-dessus...!!!
    • Je pense que std::string::append peut faire que la fonction de rappel beaucoup plus simple.
    • Vous avez raison; s->append((char*)contents. nmemb); fonctionne parfaitement avec moi et est plus concis. Aussi, le fonction officielle de signature pour le rappel a un char* comme premier argument, et vous pouvez donc l'utiliser et d'omettre le casting. Et enfin, s->resize() initialise en fait le nouvellement alloué de l'espace. Comme vous êtes sur le point de l'écraser de toute façon, s->reserve() serait plus efficace.
    InformationsquelleAutor The Quantum Physicist
  3. 7

    De lire le manuel ici: http://curl.haxx.se/libcurl/c/curl_easy_setopt.html je pense que vous avez besoin de plusieurs appels à CURL_SETOPT, la première étant l'URL que vous souhaitez traiter, la deuxième étant quelque chose comme:

    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, function_ptr);

    Où function_ptr correspond à cette signature:

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

    Ce qui se passe ici est de vous désigner une fonction de rappel qui libcurl appellera quand il a une sortie à écrire à partir de ce que le transfert que vous avez appelé. Vous pouvez l'obtenir automatiquement les écrire dans un fichier, ou de passer un pointeur vers une fonction qui va gérer la sortie elle-même. En utilisant cette fonction, vous devriez être en mesure d'assembler les différentes chaînes de sortie en un seul morceau et ensuite les utiliser dans votre programme.

    Je ne suis pas sûr de ce que d'autres options que vous pourriez avoir à régler /quoi d'autre affecte la façon dont vous voulez que votre application se comporter, alors jetez un bon coup d'oeil par le biais de cette page.

    InformationsquelleAutor