Ich weiß nicht, ob ihr mir helfen könntet?

Ich möchte gerne von einem EDIT Feld aus etwas reinschreiben.

Wenn ich jetzt auf den Button drücken möchte, dann Soll dieses reingeschriebe auf google.de's eigene EDIT-Feld übertragen werden. Automatisch muss dabei auf das Feld "Google-Suche" gedrückt werden.

Siehe Bild Nummer Eins:

http://img532.imageshack.us/img532/7615/problembild1cplusplusde.png

Danach sollen die ersten 3 Suchergebnisse (NUR Überschrift) wieder von google.de auf mein Programm übertragen werden.

Siehe Bild Nummer Zwei:

http://img532.imageshack.us/img532/9770/problembild2cplusplusde.png

Wie realisiere ich dieses Programm am Besten?

Ich benutze zZ Borland 6 auf GUI.

MfG

CiPlüPlü

Insbesondere 4. - :p

Eine externe Library also, vielen Dank für die Antwort trotzdem

@EOP:

Pffff ich bin kein DdoS-ler (Kiddie) und verspamme die Seite mit unendliche Anfragen ;o)

/e: Wolltet ihr mir was sagen ?

http://curl.haxx.se/
eignet sich auch fürs Umsetzen.

Dennoc versuche ich es mit dem vorgeschlagene Links, sieht mir sehr kompliziert aus

Wenigstens habe ich es geschafft von C++ aus eine Google anfrage zu stellen und mittels CppWebBrowser diese anzuzeigen (Link + das gesuchte Wort ^^)

Geht es wirklich nicht einfache nur einen einzigen Wert (nämlich die Überschrift) automatisch rauszukopieren und mittels Label-Feld diese auszugeben (Siehe Grafik 2; Post 1)

MfG

Geht es wirklich nicht einfache nur einen einzigen Wert (nämlich die Überschrift) automatisch rauszukopieren und mittels Label-Feld diese auszugeben

Nicht mit C++. HTTP, HTML, Sockets und "Label-Feld" gibt es dort nicht, zumindest nicht ohne externe Bibliotheken zu bemühen. Was einfacheres als Curl dürfte kaum aufzutreiben sein.

Vielleicht wäre ja eine andere Sprache, zB. Python das bessere Werkzeug dafür?

Wow vielen Dank!

Nachdem ich "curl --ssl www.google.de" als Test eingegeben habe, sehe ich nun den ganzen Quelltext! Vielen Dank!

Nun muss ich noch die Datei auslesen und fertig!!!

Vielen Dank nochmal dafür!

Mfg

Wie übergebe ich nun die Charvariable auf system("") ???

Ich habe es zwar so gelöst:

*const char Wert = Edit1->Text.c_str();

aber davor und dahinter gibt er mir immer Assemblerwerte aus.

z.B:

statt C:\txt.txt macht er ³4$C:\txt.txt~'{

Wie löse ich das Problem?

#include <iostream>
#include <vector>
#include <string>
#include <utility>

#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/algorithm/string.hpp> 

template <typename T>
class AsyncHTTPClient : boost::noncopyable
{
	public:
		AsyncHTTPClient(std::string Host,
						const std::string &Port = "80");

		const std::vector<char> GetWebPageContent() const
		{ return m_Buffer; }

	private:
		boost::asio::io_service							  m_IOService;
		boost::scoped_ptr<boost::asio::ip::tcp::resolver> m_pResolver;
		boost::asio::ip::tcp::resolver::query             m_Query;
		boost::asio::ip::tcp::socket					  m_Socket;
		std::vector<T>                                    m_Buffer;     
		const std::string                                 m_Host;
		boost::scoped_ptr<boost::thread>				  m_pThread; 

		void ResolveSuceeded(const boost::system::error_code &Error,
							 boost::asio::ip::tcp::resolver::iterator it);

		void ConnectSuceeded(const boost::system::error_code &Error);

		void ResultOfQuery(const boost::system::error_code& Error, 
						   std::size_t bytes_transferred);

		const std::pair<std::string, std::string> SplitUrl(std::string Url) const;
};

template <typename T>
AsyncHTTPClient<T>::AsyncHTTPClient(std::string Host,
								    const std::string &Port) :
	m_IOService(boost::asio::io_service::io_service()),
	m_pResolver(new boost::asio::ip::tcp::resolver(m_IOService)),
	m_Query(boost::asio::ip::tcp::resolver::query("www.google.de", Port)),
	m_Socket(m_IOService),
	m_Buffer(1500),
	m_Host(Host)
	{
		m_pResolver->async_resolve
		(
			m_Query,
			boost::bind(&AsyncHTTPClient::ResolveSuceeded, this, _1, _2)
		);

		m_pThread.reset(new boost::thread
		(
			boost::bind(&boost::asio::io_service::run, &m_IOService))
		);
	}

template <typename T>
void AsyncHTTPClient<T>::ResolveSuceeded(const boost::system::error_code &Error,
									     boost::asio::ip::tcp::resolver::iterator it)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Resolve at "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		m_Socket.async_connect
		(
			*it, 
			boost::bind(&AsyncHTTPClient::ConnectSuceeded, this, _1)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ConnectSuceeded(const boost::system::error_code &Error)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Connect to "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		std::string GET("GET ");
		GET += SplitUrl(m_Host).second;
		GET += " Host: www.google.de";

		boost::asio::write(m_Socket, boost::asio::buffer(GET)); 

		m_Socket.async_read_some
		(
			boost::asio::buffer(m_Buffer, 1500),
			boost::bind(&AsyncHTTPClient::ResultOfQuery, this, _1, _2)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ResultOfQuery(const boost::system::error_code& Error, 
							           std::size_t bytes_transferred)
{ 	
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Successfully connected to DNS-Server"<<std::endl;
		std::cout<<"... "<< bytes_transferred <<"Bytes transferred"<<std::endl;
	}
}

template <typename T>
const std::pair<std::string, std::string> AsyncHTTPClient<T>::SplitUrl(std::string Url) const
{
	std::pair<std::string, std::string> UrlPair;

	UrlPair.second = Url.substr(Url.find(std::string("/")));

	Url.erase(Url.find(std::string("/"), (Url.size() - UrlPair.second.size())));

	UrlPair.first = Url;

	return UrlPair;
}

/// Formal characters not supported
class GoogleLinkBuilder : boost::noncopyable
{
	public:
		const std::string BuildLink(const std::string &Keyword)
		{
			std::string Link("www.google.de/search?hl=de&safe=off&q=");
			Link += Keyword;
			Link += "&meta=&aq=f&aqi=&aql=&oq=&gs_rfai=";

			return Link;
		}
};

class GoogleResultParser : boost::noncopyable,
						   public GoogleLinkBuilder
{
	public:
		GoogleResultParser(const std::string &Keyword);

	private:
		boost::scoped_ptr<AsyncHTTPClient<char>> m_pClient;
		boost::scoped_ptr<boost::thread>         m_pThread;
		bool									 m_StopLoop;

		void CheckBuffer();
		void ParseResults(const std::vector<char> &Results) const;
};

GoogleResultParser::GoogleResultParser(const std::string &Keyword) :
	m_pClient(new AsyncHTTPClient<char>(BuildLink(Keyword))),
	m_pThread
	(
		new boost::thread(boost::bind(&GoogleResultParser::CheckBuffer, this))
	),
	m_StopLoop(false)
	{ }

void GoogleResultParser::CheckBuffer()
{
	while(m_StopLoop == false)
	{
		if(!m_pClient->GetWebPageContent().empty())
		{
			ParseResults(m_pClient->GetWebPageContent());

			m_StopLoop = true;
		}
	}
}

void GoogleResultParser::ParseResults(const std::vector<char> &Results) const
{
	std::cout<<"Results != empty";

	for(std::vector<char>::const_iterator it(Results.begin());
		it != Results.end();
		++it)
		std::cout<< *it <<std::endl;
}

int main()
{
	std::string Keyword;

	std::cout<<"Keyword: "<<std::endl;
	std::cin>>Keyword;

	GoogleResultParser parser(Keyword);
}

Ist das DEV++ Grafisch oder welches Programm?

Der Quellcode sieht geil aus xD

Ich wusste nedd, dass man auch Anfragen (PHP) direkt aus C++ machen kann xD

Wenn ich gestehen kann, soweit bin ich nun doch nicht :p

Entschuldigung dass ich so voreilig war ^^

Äh, wie?

CiPlüPlü schrieb:

Entschuldigung dass ich so voreilig war ^^

Äh, wie?

Lol das war bezogen auf das Thema, das ich gesagt hatte das sichs erledigt habe. Dem war es eben nicht so und ...

dann sagte ich halt:

Entschuldigung dass ich so voreilig war ^^

MfG

Achsou
Kannst du das den noch gebrauchen? Weil sonst landet das gleich im Mülleimer

Ich weiß nicht, mit welchem Programm du es gebastelt hast, weil ich es noch nicht getestet habe, aber lösche den Quellcode trotzdem nicht!

Und ja ich kann es wahrscheinlich gebrauchen ^^

Ich weiß nicht, mit welchem Programm du es gebastelt hast

Boost^^. Ist kein Programm sondern ne lib. Kannste dir 4free im Netz saugen^^

Muss ich den ganzen Ordner in meiner C++ bearbeitungsdateien beifügen oder reicht schon ein PATH aus?

Und nochmal zur Erinnerung: Es ist noch aktuell ^^

MfG

So nach langer Zeit habe ich dennoch eine Frage:

Wie bekomme ich den ganzen Quelltext in einer char Variable untergebracht???

MfG

Wie bekomme ich den ganzen Quelltext in einer char Variable untergebracht???

LOL. Wenn du das schaffst, dann melde bitte die Technik beim Patentamt, weil du dann verdammt schnell unheimlich reich wirst (Sofern der untergebrachte Quelltext nicht nur aus einem Zeichen besteht).

Was ich damit sagen will ist, dass ein char lediglich (wie es der Name sagt) 1 Zeichen aufnehmen kann. Du suchst eher nach einem string, wie z.B std::string .

#include <iostream>
#include <vector>
#include <string>
#include <utility>

#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/algorithm/string.hpp> 

template <typename T>
class AsyncHTTPClient : boost::noncopyable
{
	public:
		AsyncHTTPClient(std::string Host,
			            boost::asio::io_service &IOService,
						const std::string &Port = "80");

		const std::vector<char> GetWebPageContent() const
		{ return m_Buffer; }

	private:
		boost::scoped_ptr<boost::asio::ip::tcp::resolver> m_pResolver;
		boost::asio::ip::tcp::resolver::query             m_Query;
		boost::asio::ip::tcp::socket					  m_Socket;
		std::vector<T>                                    m_Buffer;     
		const std::string                                 m_Host;

		void ResolveSuceeded(const boost::system::error_code &Error,
							 boost::asio::ip::tcp::resolver::iterator it);

		void ConnectSuceeded(const boost::system::error_code &Error);

		void ResultOfQuery(const boost::system::error_code& Error, 
						   std::size_t bytes_transferred);

		const std::pair<std::string, std::string> SplitUrl(std::string Url) const;
};

template <typename T>
AsyncHTTPClient<T>::AsyncHTTPClient(std::string Host,
									boost::asio::io_service &IOService,
								    const std::string &Port) :
	m_pResolver(new boost::asio::ip::tcp::resolver(IOService)),
	m_Query(boost::asio::ip::tcp::resolver::query("www.google.de", Port)),
	m_Socket(IOService),
	m_Buffer(1500),
	m_Host(Host)
	{
		m_pResolver->async_resolve
		(
			m_Query,
			boost::bind(&AsyncHTTPClient::ResolveSuceeded,
										  this, 
										  boost::asio::placeholders::error, 
										  boost::asio::placeholders::iterator)
		);
	}

template <typename T>
void AsyncHTTPClient<T>::ResolveSuceeded(const boost::system::error_code &Error,
									     boost::asio::ip::tcp::resolver::iterator it)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Resolve at "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		boost::system::error_code error = boost::asio::error::host_not_found;

		boost::asio::ip::tcp::endpoint EndPoint = *it;

		m_Socket.async_connect
		(
			EndPoint, 
			boost::bind(&AsyncHTTPClient::ConnectSuceeded, this, boost::asio::placeholders::error)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ConnectSuceeded(const boost::system::error_code &Error)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Connect to "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		std::string GET("GET ");
		GET += SplitUrl(m_Host).second;
		GET += " Host: www.google.de";

		boost::asio::write(m_Socket, boost::asio::buffer(GET)); 

		m_Socket.async_read_some
		(
			boost::asio::buffer(m_Buffer, 1500),
			boost::bind(&AsyncHTTPClient::ResultOfQuery, this, boost::asio::placeholders::error, _2)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ResultOfQuery(const boost::system::error_code& Error, 
							           std::size_t bytes_transferred)
{ 	
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Successfully connected to DNS-Server"<<std::endl;
		std::cout<<"... "<< bytes_transferred <<"Bytes transferred"<<std::endl;
	}
}

template <typename T>
const std::pair<std::string, std::string> AsyncHTTPClient<T>::SplitUrl(std::string Url) const
{
	std::pair<std::string, std::string> UrlPair;

	UrlPair.second = Url.substr(Url.find(std::string("/")));

	Url.erase(Url.find(std::string("/"), (Url.size() - UrlPair.second.size())));

	UrlPair.first = Url;

	return UrlPair;
}

/// Formal characters not supported
class GoogleLinkBuilder : boost::noncopyable
{
	public:
		const std::string BuildLink(const std::string &Keyword)
		{
			std::string Link("www.google.de/search?hl=de&safe=off&q=");
			Link += Keyword;
			Link += "&meta=&aq=f&aqi=&aql=&oq=&gs_rfai=";

			return Link;
		}
};

class GoogleResultParser : boost::noncopyable,
						   public GoogleLinkBuilder
{
	public:
		GoogleResultParser(const std::string &Keyword);

	private:
		boost::asio::io_service                  m_IOService;
		boost::scoped_ptr<AsyncHTTPClient<char>> m_pClient;
		boost::scoped_ptr<boost::thread>         m_pThread;
		boost::scoped_ptr<boost::thread>         m_pIOThread;
		bool									 m_StopLoop;
		std::vector<char>						 m_TempStorage;

		void CheckBuffer();
		void ParseResults(const std::vector<char> &Results) const;
};

GoogleResultParser::GoogleResultParser(const std::string &Keyword) :
	m_IOService(boost::asio::io_service()),
	m_pClient(new AsyncHTTPClient<char>(BuildLink(Keyword), m_IOService)),
	m_pThread
	(
		new boost::thread(boost::bind(&GoogleResultParser::CheckBuffer, this))
	),
	m_pIOThread
	(
		new boost::thread(boost::bind(&boost::asio::io_service::run, &m_IOService))
	),
	m_StopLoop(false)
	{ }

void GoogleResultParser::CheckBuffer()
{
	m_TempStorage = m_pClient->GetWebPageContent();

	while(m_StopLoop == false)
	{
		if(!m_TempStorage.empty() && m_TempStorage[0] != 0)
		{
			ParseResults(m_TempStorage);

			m_StopLoop = true;
		}
	}
}

void GoogleResultParser::ParseResults(const std::vector<char> &Results) const
{
	std::cout<<"Results != empty"<<std::endl;

	for(std::vector<char>::const_iterator it(Results.begin());
		it != Results.end();
		++it)
		std::cout<< *it <<std::endl;
}

int main()
{
	std::string Keyword;

	std::cout<<"Keyword: "<<std::endl;
	std::cin>>Keyword;

	GoogleResultParser parser(Keyword);
}