Von Delphi in C/C++

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Von Delphi in C/C++

    Hi,

    bin kein Delphi-Kenner..wer kann mit diesen Code funktionsfähig in C oder C++ umschreiben!??? Danke

    Quellcode

    1. function GetConsoleOutput(const Command: String; var Output, Errors: TStringList): Boolean;
    2. var
    3. StartupInfo: TStartupInfo;
    4. ProcessInfo: TProcessInformation;
    5. SecurityAttr: TSecurityAttributes;
    6. PipeOutputRead: THandle;
    7. PipeOutputWrite: THandle;
    8. PipeErrorsRead: THandle;
    9. PipeErrorsWrite: THandle;
    10. Succeed: Boolean;
    11. Buffer: array [0..255] of Char;
    12. NumberOfBytesRead: DWORD;
    13. Stream: TMemoryStream;
    14. begin
    15. //Initialisierung ProcessInfo
    16. FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);
    18. //Initialisierung SecurityAttr
    19. FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
    20. SecurityAttr.nLength := SizeOf(SecurityAttr);
    21. SecurityAttr.bInheritHandle := true;
    22. SecurityAttr.lpSecurityDescriptor := nil;
    24. //Pipes erzeugen
    25. CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
    26. CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);
    28. //Initialisierung StartupInfo
    29. FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
    30. StartupInfo.cb:=SizeOf(StartupInfo);
    31. StartupInfo.hStdInput := 0;
    32. StartupInfo.hStdOutput := PipeOutputWrite;
    33. StartupInfo.hStdError := PipeErrorsWrite;
    34. StartupInfo.wShowWindow := sw_Hide;
    35. StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
    37. if CreateProcess(nil, PChar(command), nil, nil, true,
    38. CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil,
    39. StartupInfo, ProcessInfo) then begin
    40. result:=true;
    41. //Write-Pipes schließen
    42. CloseHandle(PipeOutputWrite);
    43. CloseHandle(PipeErrorsWrite);
    45. //Ausgabe Read-Pipe auslesen
    46. Stream := TMemoryStream.Create;
    47. try
    48. while true do begin
    49. succeed := ReadFile(PipeOutputRead, Buffer, 255, NumberOfBytesRead, nil);
    50. if not succeed then break;
    51. Stream.Write(Buffer, NumberOfBytesRead);
    52. end;
    53. Stream.Position := 0;
    54. Output.LoadFromStream(Stream);
    55. finally
    56. Stream.Free;
    57. end;
    58. CloseHandle(PipeOutputRead);
    60. //Fehler Read-Pipe auslesen
    61. Stream := TMemoryStream.Create;
    62. try
    63. while true do begin
    64. succeed := ReadFile(PipeErrorsRead, Buffer, 255, NumberOfBytesRead, nil);
    65. if not succeed then break;
    66. Stream.Write(Buffer, NumberOfBytesRead);
    67. end;
    68. Stream.Position := 0;
    69. Errors.LoadFromStream(Stream);
    70. finally
    71. Stream.Free;
    72. end;
    73. CloseHandle(PipeErrorsRead);
    75. WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    76. CloseHandle(ProcessInfo.hProcess);
    77. end
    78. else begin
    79. result:=false;
    80. CloseHandle(PipeOutputRead);
    81. CloseHandle(PipeOutputWrite);
    82. CloseHandle(PipeErrorsRead);
    83. CloseHandle(PipeErrorsWrite);
    84. end;
    85. end;
    Alles anzeigen

  • Hab ehrlichgesagt keine Lust dir deinen Code zu übersetzen. Auch wenn du kein Delphi kannst, verstehst du ja wohl was da passiert und wirst es in C++ umschreiben können oder?
    ~ mfg SeBa

    Ich beantworte keine PMs zu Computer-/Programmierproblemen. Bitte wendet euch an das entsprechende Forum.

    [Blockierte Grafik: http://i.creativecommons.org/l/by-sa/3.0/80x15.png]

  • Quellcode

    1. bool GetConsoleOutput(String sCommandLine, TStringList *Output, TStringList *Errors)
    2. {
    3. STARTUPINFO StartupInfo;
    4. PROCESS_INFORMATION ProcessInfo;
    5. SECURITY_ATTRIBUTES SecurityAttr;
    6. HANDLE PipeOutputRead, PipeOutputWrite, PipeErrorsRead, PipeErrorsWrite;
    7. bool bSucceed, bResult;
    8. char Buffer[255];
    9. DWORD dwNumberOfBytesRead;
    10. TMemoryStream *Stream;
    12. //Initialisierung ProcessInfo
    13. ZeroMemory( &ProcessInfo, sizeof(PROCESS_INFORMATION));
    15. //Initialisierung SecurityAttr
    16. ZeroMemory( &SecurityAttr, sizeof(SECURITY_ATTRIBUTES));
    17. SecurityAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    18. SecurityAttr.bInheritHandle = TRUE;
    19. SecurityAttr.lpSecurityDescriptor = NULL;
    21. //Pipes erzeugen
    22. if (!CreatePipe(&PipeOutputRead, &PipeOutputWrite, &SecurityAttr, 0))
    23. return false;
    24. if (!CreatePipe(&PipeErrorsRead, &PipeErrorsWrite, &SecurityAttr, 0))
    25. return false;
    27. //Initialisierung StartupInfo
    28. ZeroMemory( &StartupInfo, sizeof(STARTUPINFO));
    29. StartupInfo.cb = sizeof(STARTUPINFO);
    30. StartupInfo.hStdInput = 0;
    31. StartupInfo.hStdOutput = PipeOutputWrite;
    32. StartupInfo.hStdError = PipeErrorsWrite;
    33. StartupInfo.wShowWindow = SW_HIDE;
    34. StartupInfo.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
    36. if(CreateProcess(NULL, sCommandLine.c_str(), NULL, NULL,
    37. TRUE, CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS, NULL, NULL, &StartupInfo, &ProcessInfo))
    38. {
    39. bResult = true;
    40. //Write-Pipes schließen
    41. CloseHandle(PipeOutputWrite);
    42. CloseHandle(PipeErrorsWrite);
    44. //Ausgabe Read-Pipe auslesen
    45. Stream = new TMemoryStream;
    46. try
    47. {
    48. while (true)
    49. {
    50. bSucceed = ReadFile(PipeOutputRead, Buffer, 255, &dwNumberOfBytesRead, NULL);
    51. if (!bSucceed) break;
    52. Stream->Write(Buffer, dwNumberOfBytesRead);
    53. }
    54. Stream->Position = 0;
    55. Output->LoadFromStream(Stream);
    56. }
    57. __finally
    58. {
    59. delete Stream;
    60. }
    61. CloseHandle(PipeOutputRead);
    63. //Fehler Read-Pipe auslesen
    64. Stream = new TMemoryStream;
    65. try
    66. {
    67. while (true)
    68. {
    69. bSucceed = ReadFile(PipeErrorsRead, Buffer, 255, &dwNumberOfBytesRead, NULL);
    70. if (!bSucceed) break;
    71. Stream->Write(Buffer, dwNumberOfBytesRead);
    72. }
    73. Stream->Position = 0;
    74. Errors->LoadFromStream(Stream);
    75. }
    76. __finally
    77. {
    78. delete Stream;
    79. }
    80. CloseHandle(PipeErrorsRead);
    82. WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    83. CloseHandle(ProcessInfo.hProcess);
    84. }
    85. else
    86. {
    87. bResult = false;
    88. CloseHandle(PipeOutputRead);
    89. CloseHandle(PipeOutputWrite);
    90. CloseHandle(PipeErrorsRead);
    91. CloseHandle(PipeErrorsWrite);
    92. }
    93. return bResult;
    94. }
    Alles anzeigen