Discussion :

[Eric45]

Bonjour,

J'ai lu un précédent topic à ce sujet où l'on suggère d'utiliser wget, mais la solution me semble complexe, surtout que je suis débutant

A l'aide de libcurl, j'essaye d'extraire des pages web. C'est lors de l'appel de la classe que j'ai écrite, dans une méthode main(), que les erreurs de compilation apparaissent :

Voici ma classe :

**********************************libcurl_tools.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <curl/curl.h>
 
struct  MemoryStruct {
        char *memory;
        size_t size;
 
};
 
class libcurl_tools {
 
        CURL * curl_handle;
        MemoryStruct chunk;
 
        public:
 
        libcurl_tools();
        void init();
        bool close();
        void set_referrer(std::string, CURL *);
        std::string perform(std::string, CURL *);
 
};

**********************************libcurl_tools.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <curl/curl.h>
#include <curl/types.h>
#include <curl/easy.h>
 
#include <iostream> // pour std::cout
#include <string>   // pour std::string
 
#include "libcurl_tools.h"
 
libcurl_tools::libcurl_tools() {}
 
static void *myrealloc(void *ptr, size_t size)
{
        /* There might be a realloc() out there that doesn't like reallocing
           NULL pointers, so we take care of it here */
        if(ptr)
                return realloc(ptr, size);
        else
                return malloc(size);
 
}
 
static size_t WriteMemoryCallback(void *ptr, size_t size, size_t
nmemb, void *data)
{
        size_t realsize = size * nmemb;
        struct MemoryStruct *mem = (struct MemoryStruct *)data;
 
        mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize +
1);
        if (mem->memory) {
                memcpy(&(mem->memory[mem->size]), ptr, realsize);
                mem->size += realsize;
                mem->memory[mem->size] = 0;
        }
        return realsize;
 
}
 
void libcurl_tools::set_referrer(std::string referer, CURL
*curl_handle ) {
 
        curl_easy_setopt(curl_handle, CURLOPT_REFERER, referer.c_str());
 
}
 
//initialise la connection
void libcurl_tools::init() {
 
        chunk.memory=NULL; /* we expect realloc(NULL, size) to work */
        chunk.size = 0;    /* no data at this point */
 
        curl_global_init(CURL_GLOBAL_ALL);
 
        /* init the curl session */
        curl_handle = curl_easy_init();
 
}
 
//télécharge l'url en argument
std::string libcurl_tools::perform(std::string url , CURL
*curl_handle) {
 
        /* specify URL to get */
        curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
 
        /* send all data to this function  */
        curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION,
WriteMemoryCallback);
 
        /* we pass our 'chunk' struct to the callback function */
        curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
 
        /* some servers don't like requests that are made without a user-
agent
           field, so we provide one */
        curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/
1.0");
 
        /* get it! */
        curl_easy_perform(curl_handle);
 
        /* cleanup curl stuff */
        curl_easy_cleanup(curl_handle);
 
        /*
         * Now, our chunk.memory points to a memory block that is chunk.size
         * bytes big and contains the remote file.
         *
         * Do something nice with it!
         *
         * You should be aware of the fact that at this point we might have
an
         * allocated data block, and nothing has yet deallocated that data.
So when
         * you're done with it, you should free() it as a nice application.
         */
 
        //return chunk.memory; // les 2 ont l'air de marcher (pour le
moment...)
        return std::string(chunk.memory);
 
}
 
bool libcurl_tools::close() {
 
        if(chunk.memory)
                free(chunk.memory);
 
        return 0;
 
}

*********************************** test.cpp qui inclut le main()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <string>
#include <sstream>
#include "libcurl_tools.h"
 
//#include <stdio.h>
 
using namespace std;
 
int main()
{
 
 libcurl_tools e();
 
    e.init();
 
    std::string chaine;
    std:: string s = "www.yahoo.com";
 
 chaine = e.perform(s);
 
   e.close();
 
}

Là, à la compilation, trois erreurs apparaissent, concernant e.init(), e.perform(s), e.close();

Elles sont toutes les trois similaires :

test.cpp:91: erreur: request for member «init" in «e", which is of non-class type «libcurl_tools ()()"

Est ce que qqun. pourrait éclairer ma lanterne ?

Merci

[Eric45]

Merci à Koala01 pour la mise en forme du post...

Erreur bête libcurl_tools e; et non libcurl_tools e();

J'ai aussi modifié la déclaration de mes fonctions et maintenant cela fonctionne.

Merci à vous !