Hilfe bei der Umleitung der Konsolenausgabe...

jokey2 · 8. September 2006

Also der Code oben wär dann wahrscheinlich im Server und die Ausgabe wird von CreateProcess abgefangen und umgeleitet wenn ich das richtig verstanden habe.

Das hast du in etwa richtig verstanden. Eins, setzen!;-)

Doch wieso sehe ich denn gestarteten externen Prozess nicht im gleich Konsolenfenster'?

Meinst Du die Ausgabe des Prozesses?
Die Ausgabe des gestarteten Prozesses kannst Du ja nicht mehr im Konsolenfenster sehen, da sie nicht mehr auf die Konsole ausgegeben wird sondern mit ReadFile aus der Pipe in den Lesepuffer gelesen wird. An der Stelle, an der steht '//hier Programmausgabe verarbeiten (z.B. send)' kannst Du den Inhalt des Puffers auswerten. Zum Testen kannst du ihn z.B. wieder auf die Kommandozeile ausgeben (mit cout oder printf).
Dein Server sollte später an dieser Stelle eine Funktion aufrufen, die den Inhalt des Puffers an den Client sendet.

partitionist · 8. September 2006

Danke für die Aufklärung

Habe die Funktion in den Server eingefügt:

Code:

BOOL ProcessCommandLine(char * pcCommandLine)
//main...

Den empfangenen buffer mit dem Befehl gebe ich nun weiter an die Funktion ProcessCommandLine(). Dann soll sie an der beschriebenen Stelle mit send() den Buffer an den Client senden. Es gibt 2 Möglichkeiten an den Client zu senden.

1) Damit ich in der Funktion ProcessCommandLine() senden kann, muss ich den Socket übergeben damit ich das so starten kann:

Code:

send(clients[j].socket,task.c_str(),strlen(task.c_str()),0);

2) Anstatt des Rückgabetyps BOOL bei ProcessCommandLine() dachte ich mir ersetze ich ihn durch den Puffer, so kann ich in der main gleich send() mit allen Parametern verwenden.

Welche dieser Möglichkeiten ist besser?

partitionist · 8. September 2006

Bin soweit fertig, habe folgendes geändert:

Code:

ProcessCommandLine(char * pcCommandLine, SOCKET s)

Hierbei übergebe ich der Funktion den Socket des Clients.

Habe langsam die Übersicht verloren und wollte wissen was(Daten) ich überhaupt senden soll und wie ich die empfangenen Daten beim Client ausgeben soll.

Server:
send(s, Daten, strlen(Daten), 0)

Client:
recv(s, Daten, strlen(Daten), 0)

partitionist · 10. September 2006

Sorry wegen der Fragerei habs jetzt hinbekommen

Hier mein Client/Server:

Client

Code:

#include <stdlib.h> 
#include <stdio.h> 
#include <windows.h> 
#include <winsock.h> 
#include <conio.h> 
#include <string>
#include <iostream>
#include <sstream>
#include <cstdio> 
#include <vector>
#include "format.h"

using namespace std;

#pragma comment(lib,"wsock32.lib")


// Startet Winsock und gibt einige Infos zur Version aus 
// Starts winsock and dumps some infos about the version 
int startWinsock() 
{ 
   int rc; 
   WSADATA wsaData; 
   rc=WSAStartup(MAKEWORD(2,0),&wsaData); 
   
   if(rc==SOCKET_ERROR) 
   { 
      printf("Error, exiting!\n"); 
      return rc; 
   }  
   printf("System Status: %s\n",wsaData.szSystemStatus); 
   return 0; 
} 

// Sucht eine IP anhand eines Strings, der entweder die IP als String 
// oder einen Hostname enthalten kann 
long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr) 
{ 
   long rc; 
   unsigned long ip; 

   HOSTENT* he; 

   if(hostnameOrIp==NULL || addr==NULL) 
      return SOCKET_ERROR; 
   ip=inet_addr(hostnameOrIp); 

   if(ip!=INADDR_NONE)
   { 
      addr->sin_addr.s_addr=ip; 
      return 0; 
   } 
   else 
   { 
      he=gethostbyname(hostnameOrIp); 
      if(he==NULL) 
      { 
         return SOCKET_ERROR; 
      } 
      else 
      { 
         memcpy(&(addr->sin_addr),he->h_addr_list[0],4); 
      } 
      return 0; 
   } 
} 

int main(int argc, char* argv[]) 
{
    textcolor(white);
    if(argc > 2)
    {
        char* HOST = argv[1];
        int PORT = atoi(argv[2]);

        SOCKET s; 
        SOCKADDR_IN addr; 
        char c; 
        char buf[1024]; 
        char inpBuf[1024]; 
        int inpBufPos=0; 
        fd_set fdSetRead; 
        TIMEVAL timeout; 
        int rc; 


        // start winsock 
        rc=startWinsock(); 
        if(rc==SOCKET_ERROR) 
        return 1; 

        // addr vorbereiten, hostname auflösen 
        // prepare addr, resolve hostname 
        memset(&addr,0,sizeof(SOCKADDR_IN)); 
        addr.sin_family=AF_INET; 
        addr.sin_port=htons(PORT); 
        rc=getAddrFromString(HOST, &addr); 
        if(rc==SOCKET_ERROR) 
        { 
        printf("Error: Cannot resolve Host %s\n", HOST); 
        return 1; 
        } 

        // socket erstellen 
        // create socket 
        s=socket(PF_INET,SOCK_STREAM,0); 
        if(s==INVALID_SOCKET) 
        { 
        printf("Error, cannot create socket: %d\n",WSAGetLastError()); 
        return 1; 
        } 

        // verbinden.. 
        // connect.. 
        printf("Connecting...\n"); 
        rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR)); 
        if(rc==SOCKET_ERROR) 
        { 
        printf("Error: connect failed: %d\n",WSAGetLastError()); 
        return 1; 
        } 

        printf("\n"); 
        
        string str; //Eingabe String

        do
        {
            cout << "Eingabe:";
            getline(cin, str);

            if(str == "exit")
            {
                closesocket(s); 
                WSACleanup(); 
                return 0;
            }

            else if(str == "close")
            {
                rc=send(s,str.c_str(),strlen(str.c_str()),0); 
                closesocket(s); 
                WSACleanup(); 
                return 0;
            }

        
            //cout << "send->" << str << endl;
            rc=send(s,str.c_str(),strlen(str.c_str()),0); 
            if(rc==SOCKET_ERROR)
            {
                printf("Error: Sending to Server failed: %d\n",WSAGetLastError()); 
            } 
                        
            // fd_set und timeout vorbereiten 
            // prepare fd_set and timeout 
            FD_ZERO(&fdSetRead); 
            FD_SET(s,&fdSetRead); 
            timeout.tv_sec=0; 
            timeout.tv_usec=0; 

            // prüfen ob ein socket bereit ist, da timeout=0 kehrt die funktion 
            // sofort wieder zurück nach dem aufruf. 
            // achtung: das timeout auf 0 setzen oder als paremeter NULL mitgeben 
            // ist NICHT das gleiche. auf 0 gesetzt kehrt sofort zurück, während 
            // NULL blockt. 
            // check if any socket is ready (timeout=0, the function returns without delay) 
            while((rc=select(0,&fdSetRead,NULL,NULL,&timeout))>0) 
            { 
                rc=recv(s,buf,1023,0); 
                // server hat die verbindung beendet ? 
                // server closed connection ? 
                if(rc==0) 
                { 
                    printf("Server closed connection!\n"); 
                    return 1; 
                // fehler: beenden! 
                // error: abort! 
                } else if(rc==SOCKET_ERROR) 
                { 
                    printf("Error: recv failed: %d\n",WSAGetLastError()); 
                    return 1; 
                } 
                // empfangene daten ausgeben 
                // print received data 
                buf[rc]='\0'; 
                printf("%s\n",buf); 
            } 
    

        }while(rc!=SOCKET_ERROR);//Ende do-while

        // aufräumen 
        // cleanup.. 
        closesocket(s); 
        WSACleanup(); 
        printf("Client shutdown, press any key to exit\n"); 
        getch(); 

       }
       else    
       {
           cout << "Client HOST PORT" << endl;
       }
       return 0; 

}

Server:

Code:

// max. Anzahl Clients 
// Max. number of clients 
#define MAX_CLIENTS 20


// Der Standartwert für FD_SETSIZE ist 64, dieser kann aber verändert 
// werden indem man FD_SETSIZE auf einen anderen Wert setzt bevor man 
// winsock2.h includiert. 
// FD_SETSIZE auf die max. Anzahl Clients setzten 
#define FD_SETSIZE   MAX_CLIENTS 

// includes... 
#include <stdlib.h> 
#include <stdio.h> 
#include <windows.h> 
#include <winsock.h> 
#include <conio.h> 
#include <string>
#include <iostream>
#include "convert.h"
#include "registry.h"

#pragma comment(lib, "wsock32.lib")
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib,"user32.lib")

using namespace std;

// Stellt eine Verbindung mit einem Client dar 
// Represents a connection with a Client 
struct Connection 
{ 
   Connection() 
   { 
      used=false; 
      socket=INVALID_SOCKET; 
   } 
   void set(SOCKET s, SOCKADDR_IN addr) 
   { 
      this->socket=s; 
      this->addr=addr; 
      this->used=true; 
   } 
   void erase() 
   { 
      this->used=false; 
      this->socket=INVALID_SOCKET; 
   } 
   bool used;   // connection benutzt ? / connection slot used ? 
   SOCKET socket; // socket 
   SOCKADDR_IN addr; // client addr 
}; 

// clients 
Connection clients[MAX_CLIENTS]; 

// Sucht den nächsten freien Platz im clients Array 
// -1 = kein platz frei 
// Searches the next free slot in the clients array 
// -1 = no free slot 
int getFreeClientSlot() 
{ 
   for(int i=0;i<MAX_CLIENTS;i++) 
   { 
      if(clients[i].used==false) 
         return i; 
   } 
   return -1; 
} 

// Sendet eine Nachricht an alle Clients 
// Send's a Message to all clients 
/*int sendToAllClients(char* msg) 
{ 
   int rc,i; 
   for(i=0;i<MAX_CLIENTS;i++) 
   { 
      if(!clients[i].used) 
         continue; 
      rc=send(clients[i].socket,msg,strlen(msg),0); 
      if(rc==SOCKET_ERROR) 
      { 
         printf("Error: Sending to Client %d failed: %d\n",i,WSAGetLastError()); 
      } 
   } 
   return 0; 
} 
*/

// Startet Winsock und gibt einige Infos zur Version aus 
// Starts winsock and dumps some infos about the version 
int startWinsock() 
{ 
   int rc; 
   WSADATA wsaData; 
   rc=WSAStartup(MAKEWORD(2,0),&wsaData); 
   
   if(rc==SOCKET_ERROR) { 
      printf("Error, exiting!\n"); 
      return rc; 
   }   
   printf("System Status: %s\n",wsaData.szSystemStatus); 
   return 0; 
} 




#define MAX_LINE_LENGTH 1024


BOOL ProcessCommandLine(char * pcCommandLine, SOCKET s)
{
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    SECURITY_ATTRIBUTES sa;
    HANDLE hReadPipe, hWritePipe;
    DWORD dwWaitResult = WAIT_TIMEOUT, dwBytesRead, dwExitCode, dwSizeLow, dwSizeHigh, dwError;
    char cReadLine[MAX_LINE_LENGTH];
    BOOL bDoRead = TRUE, bOK = TRUE;
    MSG AppMsg;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);


    //Pipes erzeugen
    sa.nLength=sizeof(sa);
    sa.bInheritHandle=TRUE;
    sa.lpSecurityDescriptor=NULL;
    bOK = CreatePipe(&hReadPipe, &hWritePipe, &sa, 1048576);
    if(!bOK)
    {
        //FEHLER
        dwError = GetLastError();
        bOK = FALSE;
        goto PROCESS_END_NOPIPE;
    }

    //Pipes eintragen
    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.hStdOutput = hWritePipe;                        //Schreib-Ende der Pipe an Prozess übergeben
    si.hStdError = hWritePipe;                        //Schreib-Ende der Pipe an Prozess übergeben
    si.wShowWindow = SW_SHOWMINNOACTIVE;

    //Prozess starten
    bOK = CreateProcess(NULL,
                        pcCommandLine,
                        NULL,
                        NULL,
                        TRUE,
                        NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE,
                        NULL,
                        NULL,
                        &si,
                        &pi);

    if(!bOK)
    {
        //FEHLER
        dwError = GetLastError();
        goto PROCESS_END_NOPROC;
    }

    //Auf Ende warten und Messages lesen
    while(dwWaitResult != WAIT_OBJECT_0)
    {
        dwWaitResult = WaitForSingleObject(pi.hProcess, 10);
        while(dwSizeLow = GetFileSize(hReadPipe, &dwSizeHigh))
        {
            ZeroMemory(cReadLine, MAX_LINE_LENGTH);
            //Aus dem Leseende der Pipe die Progzessausgaben lesen
            if(bDoRead = ReadFile(hReadPipe, cReadLine, MAX_LINE_LENGTH - 1, &dwBytesRead, NULL))
            {
                if(dwBytesRead)
                {
                    //**** hier Programmausgabe verarbeiten (z.B. send) *******
                    send(s, cReadLine, strlen(cReadLine), 0);
                }
            }
            else
            {
                bOK = FALSE;
                dwError = GetLastError();
            }
        }
        //Applikations-Messagequeue verarbeiten
        if(PeekMessage(&AppMsg, 0, 0, 0, PM_NOREMOVE))
        {
            GetMessage(&AppMsg, 0, 0, 0);
            TranslateMessage(&AppMsg);
            DispatchMessage(&AppMsg);
        }
    }

    if(bOK)
    {
        bOK = GetExitCodeProcess(pi.hProcess, &dwExitCode);
        if(bOK)
        {
            if(dwExitCode != 0)
            {
                //Prozess kehrt mit Ergebnis != 0 zurück
                bOK = FALSE;
            }
        }
        else
        {
            //FEHLER im GetExitCodeProcess
            dwError = GetLastError();
            bOK = FALSE;
        }
    }

    //Close handles
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

PROCESS_END_NOPROC:
    CloseHandle(hWritePipe);
    CloseHandle(hReadPipe);

PROCESS_END_NOPIPE:
    return bOK;
}




int main(int argc, char* argv[]) 
{ 
    if(argc > 1)
    {
        //Startet auf dem übergebenem PORT
        int PORT = atoi(argv[1]);
    
       // SOCKET welcher neue Verbindungen annimmt 
       // SOCKET which accepts new connections 
       SOCKET acceptSocket; 
       SOCKADDR_IN addr; 
       int rc,addrsize=sizeof(SOCKADDR_IN); 
       unsigned int i,j; 
       // fd_set 
       fd_set fdSetRead; 
       // timout für select() / timeout for select() 
       timeval selectTimeout; 
       // temporär benutz für neue verbindungen 
       // temporary used for new connections 
       Connection newConnection; 
       // buffer 
       char buf[1024]; 

       // clients array leeren / clear clients array 
       memset(clients,0x0,sizeof(Connection)*MAX_CLIENTS); 

       // start winsock 
       rc=startWinsock(); 
       if(rc==SOCKET_ERROR) 
          return 1; 

       // socket erstellen / create socket 
       acceptSocket=socket(PF_INET,SOCK_STREAM,0); 
       if(acceptSocket==INVALID_SOCKET) 
       { 
          printf("Error, cannot create socket: %d\n",WSAGetLastError()); 
          return 1; 
       } 

       // sockt an port 1234 binden / bind socket to port 1234 
       memset(&addr,0,sizeof(SOCKADDR_IN)); 
       addr.sin_family=AF_INET; 
       addr.sin_port=htons(PORT); 
       addr.sin_addr.s_addr=INADDR_ANY; 
       rc=bind(acceptSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR_IN)); 
       if(rc==SOCKET_ERROR) 
       { 
          printf("Error, bind() failed: %d\n",WSAGetLastError()); 
          return 1; 
       } 

       // auf verbindungen warten / listen for connections 
       rc=listen(acceptSocket,10); 
       if(rc==SOCKET_ERROR) 
       { 
          printf("Error,listen() failed: %d\n",WSAGetLastError()); 
          return 1; 
       } 


       // The parameter readfds identifies the sockets that are to be checked for readability. 
       // If the socket is currently in the listen state, it will be marked as readable if an 
       // incoming connection request has been received such that an accept is guaranteed to 
       // complete without blocking. 
        
       while(1) 
       { 

          // fd_set leeren / clear fd_set 
          FD_ZERO(&fdSetRead); 
           
          // den socket welcher verbindungen annimmt hinzufügen 
          // add the SOCKET which accepts new connections 
           
          FD_SET(acceptSocket,&fdSetRead); 
          // alle clients hinzufügen 
          // add all clients 
          for(i=0;i<MAX_CLIENTS;i++) 
          { 
             if(clients[i].used) 
                FD_SET(clients[i].socket,&fdSetRead); 
          } 

          // warten bis irgend ein socket bereit ist, wenn timout NULL ist kehrt select() 
          // erst zurück wenn ein socket bereit ist, select() blockt also in diesem falle 
          // wait until any socket is ready (timeout = NULL, block until one socket is ready) 
          rc=select(0,&fdSetRead,NULL,NULL,NULL); 

          // abbrechen bei einem fehler 
          // break on error 
          if(rc<1) 
             break; 

          printf("select() returned %d ready sockets\n",rc); 
           
          for(i=0;i<fdSetRead.fd_count;i++) 
          { 
           
             // acceptSocket ? 
             if(fdSetRead.fd_array[i]==acceptSocket) 
             { 
                // verbindung annehmen / accept new connection 
                newConnection.socket=accept(acceptSocket,(SOCKADDR*)&newConnection.addr,&addrsize); 
                rc=getFreeClientSlot(); 
                if(rc==-1) 
                { 
                   printf("Cannot accept new clients\n"); 
                   continue; 
                } 
                // zu den clients hinzufügen 
                // add to clients 
                clients[rc]=newConnection; 
                clients[rc].used=true; 
                printf("New Client accepted from %s\n",inet_ntoa(newConnection.addr.sin_addr)); 
                continue; 
             } 
              
             // ein client ? 
             // a client ? 
             for(j=0;j<MAX_CLIENTS;j++) 
             { 
                if(!clients[j].used) 
                   continue; 

                if(clients[j].socket==fdSetRead.fd_array[i]) 
                { 
                   rc=recv(clients[j].socket,buf,1023,0); 
                   buf[rc]='\0'; 
                   // rc==0 => client hat die verbindung beendet 
                   // rc==0 => client closed connection 
                   if(rc==0) { 
                      printf("Client %d (%s): closed connection\n",j,inet_ntoa(clients[j].addr.sin_addr)); 
                      closesocket(clients[j].socket); 
                      clients[j].erase(); 
                      continue; 
                   // rc==SOCKET_ERROR => fehler, verbindung beenden! 
                   // rc==SOCKET_ERROR => error, close connection! 
                   } 
                   else if(rc==SOCKET_ERROR) 
                   { 
                      printf("Client %d (%s): Error %d\n",j,inet_ntoa(clients[j].addr.sin_addr),WSAGetLastError()); 
                      printf("Client %d (%s): Server aborts connection\n",j,inet_ntoa(clients[j].addr.sin_addr)); 
                      closesocket(clients[j].socket); 
                      clients[j].erase(); 
                      continue; 
                   // daten empfangen und an alle clients senden 
                   // receive data and send it to all clients 
                   } 
                   else 
                   { 
                       printf("Client %d (%s): Befehl: '%s' \n",j,inet_ntoa(clients[j].addr.sin_addr),buf); 
                      //sendToAllClients(buf); 
                      
                      string command = buf;
                      if(command.find(' ') != string::npos)
                      {                          
                          int pos = command.find(' ');   
                          int lang = command.length();
                            string task = command.substr(0,pos);
                          string para = command.substr(pos+1,lang);

                          string str;
                          str += '"';
                          str += reg.xmd_GetValue("bin");
                          str += "\\";
                          str += task;
                          str += ".exe";
                          str += '"';
                          str += " " + para;
                                                    
                          cout << "Erfolgreich: " << ProcessCommandLine(cvt.StringToChar(str), clients[j].socket) << endl;
                      }
                      
                      else
                      {                            
                         if(command == "close")                        
                         {
                             //rc=send(clients[i].socket,msg,strlen(msg),0); 
                             //  rc=send(clients[j].socket,task.c_str(),strlen(task.c_str()),0); 
                             closesocket(acceptSocket); 
                             WSACleanup();
                         }                         
                         cout << "Erfolgreich: " << ProcessCommandLine(cvt.StringToChar(command), clients[j].socket) << endl;
                      }          

                   } 
                } 
             } 
          }

          cout << "-----------------------------------" << endl;
       }//Ende while

       // aufräumen 
       // cleanup 
       closesocket(acceptSocket); 
       WSACleanup();        
    }
    else 
    {
        cout << "server PORT" << endl;
    }
    
    return 0;   
}

Ich hab noch ein kleines Problem, sobald ich mit dem client ein befehl übergebe dann wird nicht sofort nach der ersten Eingabe der inhalt angezeigt, sondern nach der zweiten Eingabe, woran liegt das?

jokey2 · 11. September 2006

Ersmal schön, daß es soweit funktioniert.
Was Deine Frage angeht, so verstehe ich leider nicht, was du meinst. Welche Eingabe und welcher Inhalt?
Bis dahin noch ein paar Tipps:
- Für

Code:

strlen(str.c_str())

kannst Du gleich

Code:

str.length()

verwenden

- Statt

Code:

printf("%s\n",buf);

solltest Du lieber

Code:

cout << std::string(buf) << endl;

verwenden, wenn Du C++ programmierst

partitionist · 11. September 2006

Also sobald ich etwas eingebe z.b. info und dann Enter drücke passiert garnix, d.h. es kommt noch keine ausgabe. Erst wenn ich nochmal Enter drücke ohne etwas einzugeben kommt die ausgabe von info. Hab versucht im client nochmals ein recv() einzubauen und es hat funktioniert, aber es läuft nicht stabil, wenn ich nix eingebe dann bleibt der client hängen.

jokey2 · 11. September 2006

Das muß wohl irgendwie mit dem getline zusammenhängen. Allerdings sieht da alles ok aus.
Hast Du mal einen Breakpoint nach dem getline gesetzt, ob es schon nach dem ersten oder erst nach dem 2. Enter zurückkehrt?
Welche IDE verwendest Du denn?

partitionist · 11. September 2006

Also ich verwende VC8.
Breakpoint? Könntest du mir erkären was das ist und wie ich es setze.

jokey2 · 11. September 2006

Ein Breakpoint ist eine Anweisung an den Debugger, an einer bestimmten Stelle die Programmausführung anzuhalten. Aber wenn du das nicht wei0t, dann solltest Du Dich dringend mal mit dem Thema 'Debugging' beschäftigen.

Es gibt verschiedene Arten von Breakpoints:
- Code-Breakpoints: Der Debugger hält an, wenn eine bestimmte Codezeile erreicht wurde (in meinem VS .NET 2003 kann man dazu Zeilen und Zeichennummer innerhalb einer Funktion oder einer Datei angeben oder eine Adresse im Code)
- Daten-Breakpoints: Der Debugger hält an, wenn sich der Wert einer Variablen ändert

Wenn das Programm am Breakpoint angehalten hat, kannst Du es z.B. Schritt für Schritt weiter ausführen und kannst die Arbeit Deiner Anwendung sowie die Variablen beobachten.

Wenn du mit VC8 das VisualStudio .NET 2005 meinst, dann mußt du nur im Codefenster links auf den grauen Streifen klicken, und zwar in der Zeile, in der das Programm anhalten soll. Dann erscheint dort ein großer roter Punkt, der symbolisiert den Breakpoint. Wenn das Programm diese Codezeile erreicht, wird der Debugger anhalten. Mit F10 und F11 kannst Du dann schrittweise weitergehen, wobei F11 in die Funktionen reingeht, F10 führt sie am Stück aus. Einfach mal ausprobieren.

Du mußt natürlich in den Projekteigenschaften das Debugging eingeschaltet haben. Nortmalerweise wird im Visual Studio immer mindestens eine Debug- und eine Releaseversion angelegt. Da mußt Du die Debugversion als aktive Konfiguration auswählen.

Um mehr über den Debugger zu erfahren, gib mal 'Debugger' im MSDN-Hilfe-Index ein.

partitionist · 11. September 2006

Habs aus Neugier ausprobiert mit F11 ist es wohl zu kompliziert, aber mit F10 ist es übersichtlicher. Nur das bei main() Argumente erwartet werden und wenn ich dann Schritt für Schritt debugge dann springt er gleich auf else{} da kein parameter angegben wurde.
Komme nicht drauf, wieso erst nach dem zweiten drücken der Eingabetaste die Ausgabe ausgegeben wird, liegt es hier eher am Client oder am Server

Paar Fragen:
1) In meinen Tools sind an einigen Stellen die Texte farbig hervorgehoben, doch wenn sie mit der Pipe() umgelenkt werden, wird nur eine Farbe ausgegeben, ist das möglich auch in der Pipe zu machen

2) Alle Tools funktionieren prima da sie mit parametern aufgerufen werden, doch sobald eine Eingabe mit cin >> str; in einem Tool ist so kann ich kein wert im Client eingeben da dieser die Eingabe überspringt

Hilfe bei der Umleitung der Konsolenausgabe...

jokey2

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

jokey2

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

jokey2

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

jokey2

Erfahrenes Mitglied

partitionist

Erfahrenes Mitglied

Neue Beiträge