Is er een manier om eenvoudig een HTTP-verzoek te doen met C++? Ik wil met name de inhoud van een pagina (een API) downloaden en de inhoud controleren om te zien of deze een 1 of een 0 bevat. Is het ook mogelijk om de inhoud in een string te downloaden?
Antwoord 1, autoriteit 100%
Ik had hetzelfde probleem. libcurlis echt compleet. Er is een C++-wrapper curlppdie u wellicht interesseert als u om een C++-bibliotheek vraagt. neonis een andere interessante C-bibliotheek die ook WebDAV.
curlpp lijkt natuurlijk als je C++ gebruikt. Er zijn veel voorbeelden in de brondistributie.
Om de inhoud van een URL te krijgen doe je zoiets (geëxtraheerd uit voorbeelden):
// Edit : rewritten for cURLpp 0.7.3
// Note : namespace changed, was cURLpp in 0.7.2 ...
#include <curlpp/cURLpp.hpp>
#include <curlpp/Options.hpp>
// RAII cleanup
curlpp::Cleanup myCleanup;
// Send request and get a result.
// Here I use a shortcut to get it in a string stream ...
std::ostringstream os;
os << curlpp::options::Url(std::string("http://example.com"));
string asAskedInQuestion = os.str();
Zie de examplesdirectory in curlpp brondistributie, er is een veel meer complexe gevallen, evenals een eenvoudige volledige minimalecurlpp gebruiken.
MIJN 2 CENTEN …
2, Autoriteit 45%
Windows-code:
#include <string.h>
#include <winsock2.h>
#include <windows.h>
#include <iostream>
#include <vector>
#include <locale>
#include <sstream>
using namespace std;
#pragma comment(lib,"ws2_32.lib")
int main( void ){
WSADATA wsaData;
SOCKET Socket;
SOCKADDR_IN SockAddr;
int lineCount=0;
int rowCount=0;
struct hostent *host;
locale local;
char buffer[10000];
int i = 0 ;
int nDataLength;
string website_HTML;
// website url
string url = "www.google.com";
//HTTP GET
string get_http = "GET / HTTP/1.1\r\nHost: " + url + "\r\nConnection: close\r\n\r\n";
if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0){
cout << "WSAStartup failed.\n";
system("pause");
//return 1;
}
Socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
host = gethostbyname(url.c_str());
SockAddr.sin_port=htons(80);
SockAddr.sin_family=AF_INET;
SockAddr.sin_addr.s_addr = *((unsigned long*)host->h_addr);
if(connect(Socket,(SOCKADDR*)(&SockAddr),sizeof(SockAddr)) != 0){
cout << "Could not connect";
system("pause");
//return 1;
}
// send GET / HTTP
send(Socket,get_http.c_str(), strlen(get_http.c_str()),0 );
// recieve html
while ((nDataLength = recv(Socket,buffer,10000,0)) > 0){
int i = 0;
while (buffer[i] >= 32 || buffer[i] == '\n' || buffer[i] == '\r'){
website_HTML+=buffer[i];
i += 1;
}
}
closesocket(Socket);
WSACleanup();
// Display HTML source
cout<<website_HTML;
// pause
cout<<"\n\nPress ANY key to close.\n\n";
cin.ignore(); cin.get();
return 0;
}
Hier is een veel betere implementatie:
#include <windows.h>
#include <string>
#include <stdio.h>
using std::string;
#pragma comment(lib,"ws2_32.lib")
HINSTANCE hInst;
WSADATA wsaData;
void mParseUrl(char *mUrl, string &serverName, string &filepath, string &filename);
SOCKET connectToServer(char *szServerName, WORD portNum);
int getHeaderLength(char *content);
char *readUrl2(char *szUrl, long &bytesReturnedOut, char **headerOut);
int main()
{
const int bufLen = 1024;
char *szUrl = "http://stackoverflow.com";
long fileSize;
char *memBuffer, *headerBuffer;
FILE *fp;
memBuffer = headerBuffer = NULL;
if ( WSAStartup(0x101, &wsaData) != 0)
return -1;
memBuffer = readUrl2(szUrl, fileSize, &headerBuffer);
printf("returned from readUrl\n");
printf("data returned:\n%s", memBuffer);
if (fileSize != 0)
{
printf("Got some data\n");
fp = fopen("downloaded.file", "wb");
fwrite(memBuffer, 1, fileSize, fp);
fclose(fp);
delete(memBuffer);
delete(headerBuffer);
}
WSACleanup();
return 0;
}
void mParseUrl(char *mUrl, string &serverName, string &filepath, string &filename)
{
string::size_type n;
string url = mUrl;
if (url.substr(0,7) == "http://")
url.erase(0,7);
if (url.substr(0,8) == "https://")
url.erase(0,8);
n = url.find('/');
if (n != string::npos)
{
serverName = url.substr(0,n);
filepath = url.substr(n);
n = filepath.rfind('/');
filename = filepath.substr(n+1);
}
else
{
serverName = url;
filepath = "/";
filename = "";
}
}
SOCKET connectToServer(char *szServerName, WORD portNum)
{
struct hostent *hp;
unsigned int addr;
struct sockaddr_in server;
SOCKET conn;
conn = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (conn == INVALID_SOCKET)
return NULL;
if(inet_addr(szServerName)==INADDR_NONE)
{
hp=gethostbyname(szServerName);
}
else
{
addr=inet_addr(szServerName);
hp=gethostbyaddr((char*)&addr,sizeof(addr),AF_INET);
}
if(hp==NULL)
{
closesocket(conn);
return NULL;
}
server.sin_addr.s_addr=*((unsigned long*)hp->h_addr);
server.sin_family=AF_INET;
server.sin_port=htons(portNum);
if(connect(conn,(struct sockaddr*)&server,sizeof(server)))
{
closesocket(conn);
return NULL;
}
return conn;
}
int getHeaderLength(char *content)
{
const char *srchStr1 = "\r\n\r\n", *srchStr2 = "\n\r\n\r";
char *findPos;
int ofset = -1;
findPos = strstr(content, srchStr1);
if (findPos != NULL)
{
ofset = findPos - content;
ofset += strlen(srchStr1);
}
else
{
findPos = strstr(content, srchStr2);
if (findPos != NULL)
{
ofset = findPos - content;
ofset += strlen(srchStr2);
}
}
return ofset;
}
char *readUrl2(char *szUrl, long &bytesReturnedOut, char **headerOut)
{
const int bufSize = 512;
char readBuffer[bufSize], sendBuffer[bufSize], tmpBuffer[bufSize];
char *tmpResult=NULL, *result;
SOCKET conn;
string server, filepath, filename;
long totalBytesRead, thisReadSize, headerLen;
mParseUrl(szUrl, server, filepath, filename);
///////////// step 1, connect //////////////////////
conn = connectToServer((char*)server.c_str(), 80);
///////////// step 2, send GET request /////////////
sprintf(tmpBuffer, "GET %s HTTP/1.0", filepath.c_str());
strcpy(sendBuffer, tmpBuffer);
strcat(sendBuffer, "\r\n");
sprintf(tmpBuffer, "Host: %s", server.c_str());
strcat(sendBuffer, tmpBuffer);
strcat(sendBuffer, "\r\n");
strcat(sendBuffer, "\r\n");
send(conn, sendBuffer, strlen(sendBuffer), 0);
// SetWindowText(edit3Hwnd, sendBuffer);
printf("Buffer being sent:\n%s", sendBuffer);
///////////// step 3 - get received bytes ////////////////
// Receive until the peer closes the connection
totalBytesRead = 0;
while(1)
{
memset(readBuffer, 0, bufSize);
thisReadSize = recv (conn, readBuffer, bufSize, 0);
if ( thisReadSize <= 0 )
break;
tmpResult = (char*)realloc(tmpResult, thisReadSize+totalBytesRead);
memcpy(tmpResult+totalBytesRead, readBuffer, thisReadSize);
totalBytesRead += thisReadSize;
}
headerLen = getHeaderLength(tmpResult);
long contenLen = totalBytesRead-headerLen;
result = new char[contenLen+1];
memcpy(result, tmpResult+headerLen, contenLen);
result[contenLen] = 0x0;
char *myTmp;
myTmp = new char[headerLen+1];
strncpy(myTmp, tmpResult, headerLen);
myTmp[headerLen] = NULL;
delete(tmpResult);
*headerOut = myTmp;
bytesReturnedOut = contenLen;
closesocket(conn);
return(result);
}
Antwoord 3, autoriteit 19%
Update 2020:ik heb een nieuw antwoord dat dit, nu 8 jaar oud, vervangt: https://stackoverflow.com/a/61177330/278976
Onder Linux probeerde ik cpp-netlib, libcurl, curlpp, urdl, boost::asio en overwoog ik Qt (maar wees het af op basis van de licentie). Al deze waren ofwel onvolledig voor dit gebruik, hadden slordige interfaces, hadden slechte documentatie, werden niet onderhouden of ondersteunden geen https.
Vervolgens, op suggestie van https://stackoverflow.com/a/1012577/278976, probeerde ik POCO . Wauw, ik wou dat ik dit jaren eerder had gezien. Hier is een voorbeeld van het maken van een HTTP GET-verzoek met POCO:
https://stackoverflow.com/a/26026828/2817595
POCO is gratis, open source (boost-licentie). En nee, ik heb geen enkele band met het bedrijf; Ik hou gewoon echt van hun interfaces. Goed gedaan jongens (en meiden).
https://pocoproject.org/download.html
Ik hoop dat dit iemand helpt… het kostte me drie dagen om al deze bibliotheken uit te proberen.
Antwoord 4, autoriteit 15%
Er wordt een nieuwere, minder volwassen curl-wrapper ontwikkeld genaamd C++ Requests. Hier is een eenvoudig GET-verzoek:
#include <iostream>
#include <cpr.h>
int main(int argc, char** argv) {
auto response = cpr::Get(cpr::Url{"http://httpbin.org/get"});
std::cout << response.text << std::endl;
}
Het ondersteunt een breed scala aan HTTP-werkwoorden en curl-opties. Er is hiermeer gebruiksdocumentatie.
Disclaimer: ik ben de beheerder van deze bibliotheek.
Antwoord 5, autoriteit 6%
Hier is mijn minimale wrapper rond cURL om een webpagina gewoon als een string op te halen. Dit is bijvoorbeeld handig voor unittesten. Het is eigenlijk een RAII-wikkel rond de C-code.
Installeer “libcurl” op uw computer yum install libcurl libcurl-develof gelijkwaardig.
Gebruiksvoorbeeld:
CURLplusplus client;
string x = client.Get("http://google.com");
string y = client.Get("http://yahoo.com");
Klasse-implementatie:
#include <curl/curl.h>
class CURLplusplus
{
private:
CURL* curl;
stringstream ss;
long http_code;
public:
CURLplusplus()
: curl(curl_easy_init())
, http_code(0)
{
}
~CURLplusplus()
{
if (curl) curl_easy_cleanup(curl);
}
std::string Get(const std::string& url)
{
CURLcode res;
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
ss.str("");
http_code = 0;
res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
throw std::runtime_error(curl_easy_strerror(res));
}
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
return ss.str();
}
long GetHttpCode()
{
return http_code;
}
private:
static size_t write_data(void *buffer, size_t size, size_t nmemb, void *userp)
{
return static_cast<CURLplusplus*>(userp)->Write(buffer,size,nmemb);
}
size_t Write(void *buffer, size_t size, size_t nmemb)
{
ss.write((const char*)buffer,size*nmemb);
return size*nmemb;
}
};
Antwoord 6, autoriteit 6%
Als u een C++-oplossing wilt, kunt u Qtgebruiken. Het heeft een QHttp-klasse die je kunt gebruiken.
Je kunt de docs:
raadplegen
http->setHost("qt.nokia.com");
http->get(QUrl::toPercentEncoding("/index.html"));
Qt heeft ook veel meer dat je zou kunnen gebruiken in een gewone C++ app.
Antwoord 7, autoriteit 6%
libCURLis een redelijk goede optie voor jou. Afhankelijk van wat u moet doen, moet de zelfstudieu vertellen wat u willen, speciaal voor de gemakkelijke handgreep. Maar in principe zou je dit kunnen doen om de bron van een pagina te zien:
CURL* c;
c = curl_easy_init();
curl_easy_setopt( c, CURL_URL, "www.google.com" );
curl_easy_perform( c );
curl_easy_cleanup( c );
Ik denk dat hierdoor het resultaat wordt afgedrukt naar stdout. Als je het in plaats daarvan wilt afhandelen – wat, naar ik aanneem, je doet – moet je de CURL_WRITEFUNCTION instellen. Dat alles wordt behandeld in de tutorial over krullen die hierboven is gelinkt.
Antwoord 8, autoriteit 5%
Misschien wil je C++ REST SDK(codenaam “Casablanca”) controleren. http://msdn.microsoft.com/en-us/library/jj950081.aspx
Met de C++ REST SDK kun je gemakkelijker verbinding maken met HTTP-servers vanuit je C++-app.
Gebruiksvoorbeeld:
#include <iostream>
#include <cpprest/http_client.h>
using namespace web::http; // Common HTTP functionality
using namespace web::http::client; // HTTP client features
int main(int argc, char** argv) {
http_client client("http://httpbin.org/");
http_response response;
// ordinary `get` request
response = client.request(methods::GET, "/get").get();
std::cout << response.extract_string().get() << "\n";
// working with json
response = client.request(methods::GET, "/get").get();
std::cout << "url: " << response.extract_json().get()[U("url")] << "\n";
}
De C++ REST SDK is een Microsoft-project voor cloudgebaseerde client-servercommunicatie in native code met behulp van een modern asynchroon C++ API-ontwerp.
Antwoord 9, autoriteit 5%
Bijgewerkt antwoord voor april 2020:
Ik heb onlangs veel succes gehad met cpp-httplib(zowel als een client en een server). Het is volwassen en de geschatte single-threaded RPS is ongeveer 6k.
Op het allerhoogste niveau is er een echt veelbelovend framework, cpv-framework, die ongeveer 180k RPS kan halen op twee kernen (en goed zal schalen met het aantal kernen omdat het gebaseerd is op de seastarframework, dat de snelste DB’s ter wereld aanstuurt, scylladb).
Het cpv-framework is echter nog relatief onvolwassen; dus voor de meeste toepassingen raad ik cpp-httplib ten zeerste aan.
Deze aanbeveling vervangt mijn vorige antwoord (8 jaar geleden).
Antwoord 10, autoriteit 3%
C++ biedt geen enkele manier om dit rechtstreeks te doen. Het zou volledig afhangen van welke platforms en bibliotheken je hebt.
In het ergste geval kunt u de boost::asio-bibliotheek gebruiken om een TCP-verbinding tot stand te brengen, de HTTP-headers (RFC 2616) te verzenden en de antwoorden rechtstreeks te ontleden. Kijkend naar uw toepassingsbehoeften, is dit eenvoudig genoeg om te doen.
Antwoord 11, autoriteit 2%
Hier is wat code die werkt zonder dat u een bibliotheek van derden hoeft te gebruiken:
Definieer eerst uw gateway, gebruiker, wachtwoord en eventuele andere parameters die u naar deze specifieke server moet sturen.
#define USERNAME "user"
#define PASSWORD "your password"
#define GATEWAY "your gateway"
Hier is de code zelf:
HINTERNET hOpenHandle, hResourceHandle, hConnectHandle;
const TCHAR* szHeaders = _T("Content-Type:application/json; charset=utf-8\r\n");
hOpenHandle = InternetOpen(_T("HTTPS"), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hOpenHandle == NULL)
{
return false;
}
hConnectHandle = InternetConnect(hOpenHandle,
GATEWAY,
INTERNET_DEFAULT_HTTPS_PORT,
NULL, NULL, INTERNET_SERVICE_HTTP,
0, 1);
if (hConnectHandle == NULL)
{
InternetCloseHandle(hOpenHandle);
return false;
}
hResourceHandle = HttpOpenRequest(hConnectHandle,
_T("POST"),
GATEWAY,
NULL, NULL, NULL, INTERNET_FLAG_SECURE | INTERNET_FLAG_KEEP_CONNECTION,
1);
if (hResourceHandle == NULL)
{
InternetCloseHandle(hOpenHandle);
InternetCloseHandle(hConnectHandle);
return false;
}
InternetSetOption(hResourceHandle, INTERNET_OPTION_USERNAME, (LPVOID)USERNAME, _tcslen(USERNAME));
InternetSetOption(hResourceHandle, INTERNET_OPTION_PASSWORD, (LPVOID)PASSWORD, _tcslen(PASSWORD));
std::string buf;
if (HttpSendRequest(hResourceHandle, szHeaders, 0, NULL, 0))
{
while (true)
{
std::string part;
DWORD size;
if (!InternetQueryDataAvailable(hResourceHandle, &size, 0, 0))break;
if (size == 0)break;
part.resize(size);
if (!InternetReadFile(hResourceHandle, &part[0], part.size(), &size))break;
if (size == 0)break;
part.resize(size);
buf.append(part);
}
}
if (!buf.empty())
{
// Get data back
}
InternetCloseHandle(hResourceHandle);
InternetCloseHandle(hConnectHandle);
InternetCloseHandle(hOpenHandle);
Dat zou moeten werken in een Win32 API-omgeving.
Hier is een voorbeeld.
12, Autoriteit 2%
Het HTTP-protocol is heel eenvoudig, dus het is heel eenvoudig om een HTTP-client te schrijven.
Hier is een
https://github.com/pedro-vicente/lib_netsockets
Het gebruikt HTTP om een bestand op te halen van een webserver, zowel server als bestand zijn opdrachtregelparameters. Het externe bestand wordt opgeslagen op een lokale kopie.
Disclaimer: ik ben de auteur
Controleer http.cc
https://github.com/pedro-vicente/lib_netsockets/ BLOB / MASTER / SRC / HTTP.CC
int http_client_t::get(const char *path_remote_file)
{
char buf_request[1024];
//construct request message using class input parameters
sprintf(buf_request, "GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", path_remote_file, m_server_ip.c_str());
//send request, using built in tcp_client_t socket
if (this->write_all(buf_request, (int)strlen(buf_request)) < 0)
{
return -1;
}
EDIT: bewerkte URL
Antwoord 13
C en C++ hebben geen standaardbibliotheek voor HTTP of zelfs voor socketverbindingen. In de loop der jaren zijn er enkele draagbare bibliotheken ontwikkeld. De meest gebruikte, zoals anderen al hebben gezegd, is libcurl.
Hier is een lijstmet alternatieven voor libcurl (afkomstig van de libcurl-website ).
Ook voor Linux, ditis een eenvoudige HTTP-client. Je zou je eigen eenvoudige HTTP GET-client kunnen implementeren, maar dit werkt niet als er authenticatie of omleidingen bij betrokken zijn of als je achter een proxy moet werken. Voor deze gevallen heb je een volledige bibliotheek nodig, zoals libcurl.
Voor broncode met libcurl, ditis de dichtst bij wat je wilt (Libcurl heeft veel voorbeelden). Kijk naar de hoofdfunctie. De html-inhoud wordt na een succesvolle verbinding naar de buffer gekopieerd. Vervang gewoon parseHtml door uw eigen functie.
Antwoord 14
Je kunt de embeddedRest-bibliotheek gebruiken. Het is een lichtgewicht bibliotheek met alleen headers. Het is dus gemakkelijk om het in uw project op te nemen en het vereist geen compilatie omdat er geen .cpp-bestanden in staan.
Verzoek voorbeeld van readme.mdvan repo:
#include "UrlRequest.hpp"
//...
UrlRequest request;
request.host("api.vk.com");
const auto countryId = 1;
const auto count = 1000;
request.uri("/method/database.getCities",{
{ "lang", "ru" },
{ "country_id", countryId },
{ "count", count },
{ "need_all", "1" },
});
request.addHeader("Content-Type: application/json");
auto response = std::move(request.perform());
if (response.statusCode() == 200) {
cout << "status code = " << response.statusCode() << ", body = *" << response.body() << "*" << endl;
}else{
cout << "status code = " << response.statusCode() << ", description = " << response.statusDescription() << endl;
}
Antwoord 15
Hier is wat (relatief) eenvoudige C++11-code die libCURL gebruikt om de inhoud van een URL te downloaden naar een std::vector<char>:
http_download.hh
# pragma once
#include <string>
#include <vector>
std::vector<char> download(std::string url, long* responseCode = nullptr);
http_download.cc
#include "http_download.hh"
#include <curl/curl.h>
#include <sstream>
#include <stdexcept>
using namespace std;
size_t callback(void* contents, size_t size, size_t nmemb, void* user)
{
auto chunk = reinterpret_cast<char*>(contents);
auto buffer = reinterpret_cast<vector<char>*>(user);
size_t priorSize = buffer->size();
size_t sizeIncrease = size * nmemb;
buffer->resize(priorSize + sizeIncrease);
std::copy(chunk, chunk + sizeIncrease, buffer->data() + priorSize);
return sizeIncrease;
}
vector<char> download(string url, long* responseCode)
{
vector<char> data;
curl_global_init(CURL_GLOBAL_ALL);
CURL* handle = curl_easy_init();
curl_easy_setopt(handle, CURLOPT_URL, url.c_str());
curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, callback);
curl_easy_setopt(handle, CURLOPT_WRITEDATA, &data);
curl_easy_setopt(handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
CURLcode result = curl_easy_perform(handle);
if (responseCode != nullptr)
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, responseCode);
curl_easy_cleanup(handle);
curl_global_cleanup();
if (result != CURLE_OK)
{
stringstream err;
err << "Error downloading from URL \"" << url << "\": " << curl_easy_strerror(result);
throw runtime_error(err.str());
}
return data;
}
Antwoord 16
Over het algemeen raad ik iets platformonafhankelijks aan, zoals cURL, POCO of Qt. Hier is echter een Windows-voorbeeld!:
#include <atlbase.h>
#include <msxml6.h>
#include <comutil.h> // _bstr_t
HRESULT hr;
CComPtr<IXMLHTTPRequest> request;
hr = request.CoCreateInstance(CLSID_XMLHTTP60);
hr = request->open(
_bstr_t("GET"),
_bstr_t("https://www.google.com/images/srpr/logo11w.png"),
_variant_t(VARIANT_FALSE),
_variant_t(),
_variant_t());
hr = request->send(_variant_t());
// get status - 200 if succuss
long status;
hr = request->get_status(&status);
// load image data (if url points to an image)
VARIANT responseVariant;
hr = request->get_responseStream(&responseVariant);
IStream* stream = (IStream*)responseVariant.punkVal;
CImage *image = new CImage();
image->Load(stream);
stream->Release();
Antwoord 17
Als u op zoek bent naar een HTTP-clientbibliotheek in C++ die wordt ondersteund op meerdere platforms (Linux, Windows en Mac) voor het gebruik van Restful-webservices. U kunt onderstaande opties hebben.
- QT-netwerkbibliotheek– Hiermee kan de applicatie netwerkverzoeken verzenden en ontvangen antwoorden
- C++ REST SDK– Een opkomende HTTP-bibliotheek van derden met PPL-ondersteuning
- Libcurl– Het is waarschijnlijk een van de meest gebruikte http-bibliotheken in de oorspronkelijke wereld.
Antwoord 18
Hoewel een beetje laat. Misschien geeft u de voorkeur aan https://github.com/Taymindis/backcurl.
Hiermee kunt u http-aanroepen doen op mobiele c++-ontwikkeling. Geschikt voor ontwikkeling van mobiele games
bcl::init(); // init when using
bcl::execute<std::string>([&](bcl::Request *req) {
bcl::setOpts(req, CURLOPT_URL , "http://www.google.com",
CURLOPT_FOLLOWLOCATION, 1L,
CURLOPT_WRITEFUNCTION, &bcl::writeContentCallback,
CURLOPT_WRITEDATA, req->dataPtr,
CURLOPT_USERAGENT, "libcurl-agent/1.0",
CURLOPT_RANGE, "0-200000"
);
}, [&](bcl::Response * resp) {
std::string ret = std::string(resp->getBody<std::string>()->c_str());
printf("Sync === %s\n", ret.c_str());
});
bcl::cleanUp(); // clean up when no more using
Antwoord 19
Alle antwoorden hierboven zijn nuttig. Mijn antwoord voegt alleen wat toevoegingen toe:
- Gebruik boost beast, synchronisatievoorbeeld, asyncvoorbeeld, sslvoorbeeld
- Gebruik nghttp2, voorbeeld, het ondersteunt SSL, HTTP/2
- Gebruik Facebook proxygen, dit project omvat de kern C++ HTTP-abstracties die op Facebook worden gebruikt. Het is gericht op hoge prestaties en gelijktijdigheid. Ik raad aan om het met vcpkg te installeren, anders zul je worstelen met het beheer van afhankelijkheden. Het ondersteunt SSL. Het ondersteunt ook enkele geavanceerde protocollen: HTTP/1.1, SPDY/3, SPDY/3.1, HTTP/2 en HTTP/3
Zowel nghttp2 als proxygen zijn stabiel en kunnen worden gebruikt in productie.
Antwoord 20
U kunt hiervoor ACE gebruiken:
#include "ace/SOCK_Connector.h"
int main(int argc, ACE_TCHAR* argv[])
{
//HTTP Request Header
char* szRequest = "GET /video/nice.mp4 HTTP/1.1\r\nHost: example.com\r\n\r\n";
int ilen = strlen(szRequest);
//our buffer
char output[16*1024];
ACE_INET_Addr server (80, "example.com");
ACE_SOCK_Stream peer;
ACE_SOCK_Connector connector;
int ires = connector.connect(peer, server);
int sum = 0;
peer.send(szRequest, ilen);
while (true)
{
ACE_Time_Value timeout = ACE_Time_Value(15);
int rc = peer.recv_n(output, 16*1024, &timeout);
if (rc == -1)
{
break;
}
sum += rc;
}
peer.close();
printf("Bytes transffered: %d",sum);
return 0;
}
21
CPPRest SDK BY MS is wat ik net heb gevonden en na ongeveer 1/2 uur had mijn eerste eenvoudige webservice-oproep aan het werk. Vergeleken met anderen die hier noemden waar ik niet in staat was om iets te laten installeren na uren van kijken, zou ik zeggen dat het behoorlijk indrukwekkend is
https://github.com/microsoft/cpprestsdk
Scroll naar beneden en klik op Documentatie en klik vervolgens op Tutorial aan de slag en je hebt een eenvoudige app in geen tijd.