sapzero
Goto Top

Cplusplus Consolen Code in VCL Code umschreiben

Hi,
ich habe einen C++ Quellcode in Console will es Jedoch in VCL umschreiben aber es Funktioniert nicht. Könnte jemand mir dabei Helfen würd mich sehr freuen.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit2.h" 
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm" 
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

/////////////////////////////// hier drüber ist der VCL Formular ////////////////////// 

///////// hier unten fängt die Consolen Anwendung an ///  ich versuche es oben einzubauen weis aber nicht wie es geht /////////////

#include <iostream>
#include <fstream>
#include <stdexcept> {{comment_single_line_double_slash:6}}
#include <sstream>
#ifdef linux
#include <sys/socket.h> {{comment_single_line_double_slash:7}}
#include <arpa/inet.h> {{comment_single_line_double_slash:8}}
#include <netdb.h> {{comment_single_line_double_slash:9}}
#include <errno.h> {{comment_single_line_double_slash:10}}
#else
#include <winsock2.h>
#endif
using namespace std;

std::runtime_error CreateSocketError()
{
    std::ostringstream temp;
#ifdef linux
    temp << "Socket-Fehler #" << errno << ": " << strerror(errno);  
#else
    int error = WSAGetLastError();
    temp << "Socket-Fehler #" << error;  
    char* msg;
    if(FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                     NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                     reinterpret_cast<char*>(&msg), 0, NULL))
    {
        try
        {
            temp << ": " << msg;  
            LocalFree(msg);
        }
        catch(...)
        {
            LocalFree(msg);
            throw;
        }
    }
#endif
    return std::runtime_error(temp.str());
}

void SendAll(int socket, const char* const buf, const int size)
{
    int bytesSent = 0; // Anzahl Bytes die wir bereits vom Buffer gesendet haben
    do
    {
        int result = send(socket, buf + bytesSent, size - bytesSent, 0);
        if(result < 0) // Wenn send einen Wert < 0 zurück gibt deutet dies auf einen Fehler hin.
        {
            throw CreateSocketError();
        }
        bytesSent += result;
    } while(bytesSent < size);
}

// Liest eine Zeile des Sockets in einen stringstream
void GetLine(int socket, std::stringstream& line)
{
    for(char c; recv(socket, &c, 1, 0) > 0; line << c)
    {
        if(c == '\n')  
        {
            return;
        }
    }
    throw CreateSocketError();
}

// Entfernt das http:// vor dem URL
void RemoveHttp(std::string& URL)
{
    size_t pos = URL.find("http://");  
    if(pos != std::string::npos)
    {
        URL.erase(0, 7);
    }
}

// Gibt die Dateiendung im URL zurück
std::string GetFileEnding(std::string& URL)
{
    using namespace std;
    size_t pos = URL.rfind(".");  
    if(pos == string::npos)
    {
        return "";  
    }
    URL.erase(0, pos);
    string ending = ".";  
    // Algorithmus um Sachen wie ?index=home nicht zuzulassen
    for(string::iterator it = URL.begin() + 1; it != URL.end(); ++it)
    {
        if(isalpha(*it))
        {
            ending += *it;
        }
        else
        {
            break;
        }
    }
    return ending;
}

// Gibt den Hostnamen zurück und entfernt ihn aus der URL, sodass nur noch der Pfad übrigbleibt
std::string RemoveHostname(std::string& URL)
{
    size_t pos = URL.find("/");  
    if(pos == std::string::npos)
    {
        std::string temp = URL;
        URL = "/";  
        return temp;
    }
    std::string temp = URL.substr(0, pos);
    URL.erase(0, pos);
    return temp;
}

int main()
{
    using namespace std;

	//cout << "URL: "; 
	Memo1->Lines->Add("Bitte URL eingeben!\n");  
	UnicodeString URL = Edit1->Text;
    //cin >> URL; // User gibt URL der Datei ein, die herruntergeladen werden soll

#ifndef linux
    WSADATA w;
    if(int result = WSAStartup(MAKEWORD(2,2), &w) != 0)
    {
		//cout << "Winsock 2 konnte nicht gestartet werden! Error #" << result << endl; 
		Memo1->Lines->Add("Winsock 2 konnte nicht gestartet werden!\n");  
		return 1;
    }
#endif

    RemoveHttp(URL);

    string hostname = RemoveHostname(URL);

    hostent* phe = gethostbyname(hostname.c_str());

    if(phe == NULL)
    {
		//cout << "Host konnte nicht aufgeloest werden!" << endl; 
		Memo1->Lines->Add("Host konnte nicht aufgeloest werden!\n");  
        return 1;
    }

    if(phe->h_addrtype != AF_INET)
    {
		//cout << "Ungueltiger Adresstyp!" << endl; 
		Memo1->Lines->Add("Ungueltiger Adresstyp!\n");  
		return 1;
    }

    if(phe->h_length != 4)
    {
		//cout << "Ungueltiger IP-Typ!" << endl; 
		Memo1->Lines->Add("Ungueltiger IP-Typ!\n");  
        return 1;
    }

    int Socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(Socket == -1)
    {
		//cout << "Socket konnte nicht erstellt werden!" << endl; 
		Memo1->Lines->Add("Socket konnte nicht erstellt werden!\n");  
		return 1;
    }

    sockaddr_in service;
    service.sin_family = AF_INET;
    service.sin_port = htons(80); // Das HTTP-Protokoll benutzt Port 80

    char** p = phe->h_addr_list; // p mit erstem Listenelement initialisieren
    int result; // Ergebnis von connect
    do
    {
        if(*p == NULL) // Ende der Liste
		{
			//cout << "Verbindung fehlgschlagen!" << endl; 
			Memo1->Lines->Add("Verbindung fehlgschlagen!\n");  
            return 1;
        }

        service.sin_addr.s_addr = *reinterpret_cast<unsigned long*>(*p);
        ++p;
        result = connect(Socket, reinterpret_cast<sockaddr*>(&service), sizeof(service));
    }
    while(result == -1);

	//cout << "Verbindung erfolgreich!" << endl; 
	Memo1->Lines->Add("Verbindung erfolgreich!\n");  

    string request = "GET ";  
    request += URL;    // z.B. /faq/index.html
    request += " HTTP/1.1\n";  
    request += "Host: " + hostname + "\nConnection: close\n\n";  

    try
    {
        SendAll(Socket, request.c_str(), request.size());

        int code = 100; // 100 = Continue
        string Protokoll;
        stringstream firstLine; // Die erste Linie ist anders aufgebaut als der Rest
        while(code == 100)
        {
            GetLine(Socket, firstLine);
            firstLine >> Protokoll;
            firstLine >> code;
            if(code == 100)
            {
                GetLine(Socket, firstLine); // Leere Zeile nach Continue ignorieren
            }
        }
		//cout << "Protokoll: " << Protokoll << endl; 
		Memo1->Lines->Add("Protokoll: "+Protokoll+"\n");  

        if(code != 200)
        {
            firstLine.ignore(); // Leerzeichen nach dem Statuscode ignorieren
            string msg;
            getline(firstLine, msg);
			//cout << "Error #" << code << " - " << msg << endl; 
			Memo1->Lines->Add("Fehler: "+std::string(code)+"-"+msg+"\n");  
			return 0;
        }

        bool chunked = false;
        const int noSizeGiven = -1;
        int size = noSizeGiven;

        while(true)
        {
            stringstream sstream;
            GetLine(Socket, sstream);
            if(sstream.str() == "\r") // Header zu Ende?  
            {
                break;
            }
            string left; // Das was links steht
            sstream >> left;
            sstream.ignore(); // ignoriert Leerzeichen
            if(left == "Content-Length:")  
            {
                sstream >> size;
            }
            if(left == "Transfer-Encoding:")  
            {
                string transferEncoding;
                sstream >> transferEncoding;
                if(transferEncoding == "chunked")  
                {
                    chunked = true;
                }
            }
        }

        string filename = "download" + GetFileEnding(URL);  
		//cout << "Filename: " << filename << endl; 
		Memo1->Lines->Add("Filname: "+filename+"\n");  
        fstream fout(filename.c_str(), ios::binary | ios::out);
        if(!fout)
        {
			//cout << "Could Not Create File!" << endl; 
			Memo1->Lines->Add("Could Not Create File!\n");  
			return 1;
        }
        int recvSize = 0; // Empfangene Bytes insgesamt
        char buf[1024];
        int bytesRecv = -1; // Empfangene Bytes des letzten recv

        if(size != noSizeGiven) // Wenn die Größe über Content-length gegeben wurde
        {
            cout << "0%";  
            while(recvSize < size)
            {
                if((bytesRecv = recv(Socket, buf, sizeof(buf), 0)) <= 0)
                {
                    throw CreateSocketError();
                }
                recvSize += bytesRecv;
                fout.write(buf, bytesRecv);
				cout << "\r" << recvSize * 100 / size << "%" << flush; // Mit \r springen wir an den Anfang der Zeile  
				Memo1->Lines->Add("\r"+IntToStr(recvSize * 100 / size)+"%");  
			}
		}
        else
        {
            if(!chunked)
            {
				//cout << "Downloading... (Unknown Filesize)" << endl; 
				Memo1->Lines->Add("Downloading... (Unknown Filesize)\n");  
				while(bytesRecv != 0) // Wenn recv 0 zurück gibt, wurde die Verbindung beendet
                {
                    if((bytesRecv = recv(Socket, buf, sizeof(buf), 0)) < 0)
                    {
                        throw CreateSocketError();
                    }
                    fout.write(buf, bytesRecv);
                }
            }
            else
            {
				//cout << "Downloading... (Chunked)" << endl; 
				Memo1->Lines->Add("Downloading... (Chunked)\n");  
                while(true)
                {
                    stringstream sstream;
                    GetLine(Socket, sstream);
                    int chunkSize = -1;
                    sstream >> hex >> chunkSize; // Größe des nächsten Parts einlesen
                    if(chunkSize <= 0)
                    {
                        break;
                    }
					//cout << "Downloading Part (" << chunkSize << " Bytes)... " << endl; 
					Memo1->Lines->Add("Downloading Part ("+IntToStr(chunkSize)+" Bytes)... \n");  
                    recvSize = 0; // Vor jeder Schleife wieder auf 0 setzen
                    while(recvSize < chunkSize)
                    {
                        int bytesToRecv = chunkSize - recvSize;
						if((bytesRecv = recv(Socket, buf, bytesToRecv > sizeof(buf) ? sizeof(buf) : bytesToRecv, 0)) <= 0)
                        {
                            throw CreateSocketError();
                        }
                        recvSize += bytesRecv;
                        fout.write(buf, bytesRecv);
						//cout << "\r" << recvSize * 100 / chunkSize << "%" << flush; 
						Memo1->Lines->Add("\r"+IntToStr(recvSize * 100 / chunkSize)+"%");  
					}
					cout << endl;
					for(int i = 0; i < 2; ++i)
                    {
                        char temp;
                        recv(Socket, &temp, 1, 0);
                    }
				}
            }
        }
		//cout << endl << "Finished!" << endl; 
		Memo1->Lines->Add("\nFinished!\n");  
    }
    catch(exception& e)
    {
		//cout << endl;
		Memo1->Lines->Add("\n");  
		cerr << e.what() << endl;
		Memo1->Lines->Add(string(e.what())+"\n");  
    }
#ifdef linux
    close(Socket); // Verbindung beenden
#else
    closesocket(Socket); // Windows-Variante
#endif
system("pause");  
}

Gruß

Sapzero

Content-ID: 126883

Url: https://administrator.de/contentid/126883

Ausgedruckt am: 22.11.2024 um 19:11 Uhr

maretz
maretz 12.10.2009 um 06:55:59 Uhr
Goto Top
Moin,

du willst den Code umschreiben? Wie denn? In Arial, 10pt? Oder lieber WingDings 15pt? Hier hilft dir Word (oder OpenOffice...). Alternativ kannst du den auch zu Java, PHP oder Turbo Pascal umschreiben. Da kannst du den Compiler runterladen und loslegen - meinen Segen hast du!

Oder du formulierst deine Frage nochmal so das man die auch versteht und sagst mal was genau du willst...
Sapzero
Sapzero 12.10.2009 um 12:20:49 Uhr
Goto Top
Hi,
also nochmal ich habe eine Consolen Anwendung in C++. Ich will es jedoch in C++ VCL Formular umschreiben mit einer GUI, damit ich mir eine grafische Benutzeroberfläche bauen kann.
Ich kenn mich nicht ganz damit aus und habs versucht umzuschreiben, jedoch konnte ich es nicht ganz Intergrieren ind den Formular und Bräuchte Hilfe.

Ganz oben in dem Code ist Der VCL Formular mit den dazugehörigen Bibliotheken. Unter dem Formular ist die Consolen Anwendung mit den dazugehörigen Bibliotheken, jedoch weis ich nicht welche ich von denen noch gebrauchen kannund welche nicht.

Die Fehlermeldungen die noch auftauchen, die ich nicht beheben Konnte sind die hier:
[BCC32 Fehler] Unit2.cpp(146): E2451 Undefiniertes Symbol 'Memo1'
[BCC32 Fehler] Unit2.cpp(147): E2451 Undefiniertes Symbol 'Edit1'
[BCC32 Fehler] Unit2.cpp(160): E2357 Eine mit 'UnicodeString' initialisierte Referenz-Variable muss einen L-Wert des Typs 'string' haben
[BCC32 Fehler] Unit2.cpp(160): E2342 Keine Übereinstimmung des Typs beim Parameter 'URL' ('string &' erwartet, 'UnicodeString' erhalten)
[BCC32 Fehler] Unit2.cpp(162): E2357 Eine mit 'UnicodeString' initialisierte Referenz-Variable muss einen L-Wert des Typs 'string' haben
[BCC32 Fehler] Unit2.cpp(162): E2342 Keine Übereinstimmung des Typs beim Parameter 'URL' ('string &' erwartet, 'UnicodeString' erhalten)
[BCC32 Fehler] Unit2.cpp(220): E2094 'operator+=' ist im Typ 'string' für Argumente des Typs 'UnicodeString' nicht implementiert
[BCC32 Fehler] Unit2.cpp(250): E2285 Keine Übereinstimmung für 'string::basic_string(int)' gefunden
[BCC32 Fehler] Unit2.cpp(250): E2031 Typumwandlung von 'int' nach 'string' nicht zulässig
[BCC32 Fehler] Unit2.cpp(284): E2357 Eine mit 'UnicodeString' initialisierte Referenz-Variable muss einen L-Wert des Typs 'string' haben
[BCC32 Fehler] Unit2.cpp(284): E2342 Keine Übereinstimmung des Typs beim Parameter 'URL' ('string &' erwartet, 'UnicodeString' erhalten)
[BCC32 Warnung] Unit2.cpp(348): W8012 Vergleich von signed- und unsigned-Werten