how to make Google search using c++ program - c++

Question

I am wondering and almost searched everywhere on the web but couldn't find anything helpful. I am quite a beginner with c++. Is there any possible way to make a Web search when I type a word in console on program runtime, it should go to google.com and fetch the meaning of that word to my .txt file or directly on my console? Basically, I am trying to implement a dictionary (offline+Online) using c++ and linked lists/trees.
Any sort of help will be much appreciated.

Answer 1

There is a couple of steps to this that you may need to do before you even start writing the C++ code.
Note: C++ is probably not the easiest language to do this in.
You will need a google account.
Go to the website and sign up (free)
You will need to get an API Key
Go to the website and generate (free)
You will need to know the REST command to generate output.
Here the easiest thing to do is to use CURL to test your REST query (or use a tool like PostMan). Though their website provides a simple starting point to test parameters.
Once you have the rest command working on the command line. Convert this to C code using the libcurl API.
You will need to parse the returned value.
The returned value is JSON you will need to either parse this manually or use an existing library. There are several out there. I hear jsoncpp is good I prefer ThorsSerializer but I wrote that so I am biased.
Making a dictionary (non commercial).
Its probably simpler to use the MERRIAM-WEBSTER'S API rather than googles.
Step 1: Register to get an API Key
https://dictionaryapi.com/register/index
Step 2: Get The API Key
Once you have filled out the form.
And confirmed your e-mail
And Logged into dictionaryapi.com
Go to your keys page
Step 3: Verify you can get information from the command line
Documentation here
Note: My key is not going to work for you (I deleted it). You will have to create and use your own.
curl https://www.dictionaryapi.com/api/v3/references/collegiate/json/voluminous?key=568e93fa-c06f-4f96-bf12-948cf301a03f
Step 4: Convert the command line into C code.
#include <string>
#include <iostream>
#include <curl/curl.h>
extern "C" size_t write_callback(char *ptr, size_t size, size_t nmemb, void *dataFromServerVoid)
{
std::string& dataFromServer = *(reinterpret_cast<std::string*>(dataFromServerVoid));
dataFromServer.append(ptr, size * nmemb);
return size * nmemb;
}
int main(int argc, char* argv[])
{
if (argc < 2) {
std::cerr << "Fail: Read Instructions\n";
return -1;
}
std::cout << "Dictionary:\n"
<< " Getting: " << argv[1] << "\n";
CURL* curl = curl_easy_init();
if (curl)
{
static const std::string apiKey = "?key=568e93fa-c06f-4f96-bf12-948cf301a03f";
static const std::string urlBase = "https://www.dictionaryapi.com/api/v3/references/collegiate/json/";
const std::string url = urlBase + argv[1] + apiKey;
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
// The default action is to print any data returned
// to the standard output. But we are going to need to
// processes that data so adding some functions
// and data to capture the output.
std::string dataFromServer;
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &dataFromServer);
// Get the data from the server.
CURLcode res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
// If the call worked we can print out
// what we retrieved.
if (res == CURLE_OK) {
std::cout << " Got: >" << dataFromServer << "<\n";
}
}
}
Step 5: Build and verify it works.
> g++ -std=c++17 dict.cpp -lcurl
> ./a.out bootstrap
We get:
Dictionary:
Getting: bootstrap
Got: >[{"meta":{"id":"bootstrap:1","uuid":"9c960ec2-a3ce-4f09-a7ba-a4972036314a","sort":"020350800","src":"collegiate","section":"alpha","stems":["bootstrap","bootstraps"],"offensive":false},"hom":1,"hwi":{"hw":"boot*strap","prs":[{"mw":"\u02c8b\u00fct-\u02ccstrap","sound":{"audio":"bootst01","ref":"c","stat":"1"}}]},"fl":"noun","def":[{"sseq":[[["sense",{"sn":"1","dt":[["text","{bc}a looped strap sewed at the side or the rear top of a boot to help in pulling it on"]]}]],[["sense",{"sn":"2","ins":[{"if":"boot*straps","spl":"plural"}],"dt":[["text","{bc}unaided efforts "],["uns",[[["text","often used in the phrase {it}by one\u0027s own bootstraps{\/it}"]]]]]}]]]}],"date":"1875{ds||1||}","shortdef":["a looped strap sewed at the side or the rear top of a boot to help in pulling it on","unaided efforts \u2014often used in the phrase by one\u0027s own bootstraps"]},{"meta":{"id":"bootstrap:2","uuid":"59331df1-c1fd-44ff-bd8d-73d471ad6819","sort":"020350900","src":"collegiate","section":"alpha","stems":["bootstrap"],"offensive":false},"hom":2,"hwi":{"hw":"bootstrap"},"fl":"adjective","def":[{"sseq":[[["sense",{"sn":"1","dt":[["text","{bc}designed to function independently of outside direction {bc}capable of using one internal function or process to control another "],["vis",[{"t":"a {wi}bootstrap{\/wi} operation to load a computer"}]]]}]],[["sense",{"sn":"2","dt":[["text","{bc}carried out with minimum resources or advantages "],["vis",[{"t":"{wi}bootstrap{\/wi} efforts"}]]]}]]]}],"date":"1926{ds||1||}","shortdef":["designed to function independently of outside direction : capable of using one internal function or process to control another","carried out with minimum resources or advantages"]},{"meta":{"id":"bootstrap:3","uuid":"257edd7e-c31a-453a-a15b-e1d022c70d96","sort":"020351000","src":"collegiate","section":"alpha","stems":["bootstrap","bootstrapped","bootstrapper","bootstrappers","bootstrapping","bootstraps"],"offensive":false},"hom":3,"hwi":{"hw":"bootstrap"},"fl":"verb","ins":[{"if":"boot*strapped"},{"if":"boot*strap*ping"}],"def":[{"vd":"transitive verb","sseq":[[["sense",{"dt":[["text","{bc}to promote or develop by initiative and effort with little or no assistance "],["vis",[{"t":"{it}bootstrapped{\/it} herself to the top"},{"t":"\u2026 turns out to be pretty talented at identifying and {wi}bootstrapping{\/wi} promising creative endeavors.","aq":{"auth":"Harry McCracken"}}]]]}]]]}],"uros":[{"ure":"boot*strap*per","fl":"noun"}],"date":"1951","shortdef":["to promote or develop by initiative and effort with little or no assistance"]}]<
Step 6: Extract the data from the JSON
I am going to use ThorsSerializer to get the data. This allows de-serialization of JSON directly into C++ objects without having to parse and interpret any intermediate objects. This makes it really usefull for stable web interfaces (like most REST interfaces).
Step 6a: Install ThorsSerializer
> brew install thors-serializer
A useful tip here. To visualize and quickly see the JSON there is a great command line tool jq. if you stream JSON to this the default action is simply to prity print the JSON (though it has a lot more power)
> brew install jq
> echo "<JSON TEXT>" | jq
Step 6b: Build Definition of what you want:
Looking at the definition of JSON we only need one bit of data "shortdef" which is an array of strings inside a definition object.
// So simply declare an object like the JSON declaraition.
// You can ignore any parts of the JSON you don't want.
struct Definition
{
std::vector<std::string> shortdef;
};
// Now tell the ThorsSerializer the bits it needs to understand.
// The library already knows how to handle all the standard types.
// So no extra declarations needed for std::vector.
ThorsAnvil_MakeTrait(Definition, shortdef);
Step 6C: Write code to extract data from JSON.
using ThorsAnvil::Serialize::jsonImporter;
std::stringstream dataFromServerStream(dataFromServer);
std::vector<Definition> definition;
// ThorsSerializer works for any type of stream.
// Files are supported natively and its not hard
// to wrap sockets as a stream if you want to.
// In this case I have kept it simple.
dataFromServerStream >> jsonImporter(definition);
Step 6c: Put it all together:
#include <vector>
#include <string>
#include <iostream>
#include <curl/curl.h>
#include "ThorSerialize/Traits.h"
#include "ThorSerialize/JsonThor.h"
extern "C" size_t write_callback(char *ptr, size_t size, size_t nmemb, void *dataFromServerVoid)
{
std::string& dataFromServer = *(reinterpret_cast<std::string*>(dataFromServerVoid));
dataFromServer.append(ptr, size * nmemb);
return size * nmemb;
}
struct Definition
{
std::vector<std::string> shortdef;
};
ThorsAnvil_MakeTrait(Definition, shortdef);
int main(int argc, char* argv[])
{
if (argc < 2) {
std::cerr << "Fail: Read Instructions\n";
return -1;
}
std::cout << "Dictionary:\n"
<< "Getting: " << argv[1] << "\n";
CURL* curl = curl_easy_init();
if (curl)
{
static const std::string apiKey = "?key=568e93fa-c06f-4f96-bf12-948cf301a03f";
static const std::string urlBase = "https://www.dictionaryapi.com/api/v3/references/collegiate/json/";
const std::string url = urlBase + argv[1] + apiKey;
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
std::string dataFromServer;
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &dataFromServer);
CURLcode res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if (res == CURLE_OK) {
using ThorsAnvil::Serialize::jsonImporter;
std::stringstream dataFromServerStream(dataFromServer);
std::vector<Definition> definition;
dataFromServerStream >> jsonImporter(std::move(definition));
for(auto def: definition[0].shortdef) {
std::cout << " " << def << "\n";
}
}
}
}
Step 7: Build
g++ -std=c++17 main2.cpp -lcurl -lThorSerialize17 -lThorsLogging17
> ./a.out bootstrap
We get:
Dictionary:
Getting: bootstrap
a looped strap sewed at the side or the rear top of a boot to help in pulling it on
unaided efforts —often used in the phrase by one's own bootstraps
Just as a comparison.
The same code in Javascript. Now my javascript is not good. But this code is still tighter and more readable. So this shows that C++ is not the best language to do this as a beginner.
const fetch = require('node-fetch');
const apiKey = "?key=568e93fa-c06f-4f96-bf12-948cf301a03f";
const urlBase = "https://www.dictionaryapi.com/api/v3/references/collegiate/json/";
const url = urlBase + process.argv[2] + apiKey;
fetch(url)
.then(res => res.json())
.then((definition) => {
for(var item in definition[0].shortdef) {
console.log(definition[0].shortdef[item]);
}
})
.catch(err => { throw err });
To run this:
> node dict.js bootstrap
But saying that. If you find an appropriate library this code can be just as concise as the Javascript. But you need an appropriate library (which may be difficult and hard to find/build and install). All of which are made easy with javascript.
Example of simple version:
#include <vector>
#include <string>
#include <iostream>
#include "ThorSerialize/Traits.h"
#include "ThorSerialize/JsonThor.h"
#include "ThorSocketStream/ThorsSimpleStream.h"
struct Definition
{
std::vector<std::string> shortdef;
};
ThorsAnvil_MakeTrait(Definition, date, shortdef);
int main(int argc, char* argv[])
{
using ThorsAnvil::Stream::IThorSimpleStream;
using ThorsAnvil::Serialize::jsonImporter;
static const std::string apiKey = "?key=key=568e93fa-c06f-4f96-bf12-948cf301a03f";
static const std::string urlBase = "https://www.dictionaryapi.com/api/v3/references/collegiate/json/";
const std::string url = urlBase + argv[1] + apiKey;
IThorSimpleStream stream(url);
std::vector<Definition> dataFromServer;
stream >> jsonImporter(dataFromServer)
for(auto const& def: dataFromServer[0].shortdef) {
std::cout << " " << data << "\n";
}
}
But getting the SimpleStream library may take some work to build.