进程管道通信出现乱码，请指导一下

康小泡

如题，我在写进程通过管道通信的时候，遇到进程通信消息不稳定的情况，它的 消息内容有时候是完全正常的，有时候却会出现乱码


这里

1. // SendMessage.cpp : 定义控制台应用程序的入口点。
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. #include <Windows.h>
   
6. 
   
7. int _tmain(int argc, _TCHAR* argv[])
   
8. {
   
9.         HANDLE hRead ;
   
10.         HANDLE hWrite ;
    
11. 
    
12.         SECURITY_ATTRIBUTES sa ;
    
13.         sa.nLength = sizeof(sa);
    
14.         sa.lpSecurityDescriptor = NULL;
    
15.         sa.bInheritHandle = TRUE ;     //指定管道句柄可被继承
    
16.         BOOL bRet = CreatePipe(&hRead,&hWrite,&sa,0);        //创建匿名管道
    
17. 
    
18.         if(bRet == TRUE){
    
19.                 printf("成功创建匿名管道\n");
    
20.         }else{
    
21.                 printf("创建匿名管道失败,%d\n",GetLastError());
    
22.         }
    
23.         HANDLE hTemp = GetStdHandle(STD_OUTPUT_HANDLE);//获得本进程当前标准输出，以备将来恢复
    
24. 
    
25.         SetStdHandle(STD_OUTPUT_HANDLE,hWrite);
    
26.         STARTUPINFO si;
    
27.         GetStartupInfo(&si) ;
    
28.         PROCESS_INFORMATION pi;
    
29. 
    
30.         si.dwFlags = STARTF_USESHOWWINDOW;
    
31.         si.wShowWindow = TRUE ;
    
32.         TCHAR szCommandLine[] = TEXT("C:\\代码\\管道通信\\Client\\Debug\\Client.exe");
    
33.         bRet = CreateProcess(NULL,szCommandLine,NULL,NULL,TRUE,NULL,NULL,NULL,&si,&pi);
    
34.         SetStdHandle(STD_OUTPUT_HANDLE,hTemp); //恢复本进程标准输出
    
35. 
    
36.         if (bRet == TRUE){
    
37.                 printf("创建子进程成功\n");
    
38.         }else{
    
39.                 printf("创建子进程失败，错误代码:%d\n",GetLastError());
    
40.         }
    
41.         char ReadBuf[100]={0};
    
42.         DWORD ReadNum;
    
43. 
    
44.         do{
    
45.                 ZeroMemory(ReadBuf,100);
    
46.                 BOOL bRet = ReadFile(hRead,ReadBuf,100,&ReadNum,NULL);
    
47.                 ReadBuf[ReadNum] = '\0';
    
48.                 printf("从管道读取%d字节数据:[%s]\n",ReadNum,ReadBuf);
    
49.         } while (bRet);
    
50.         if (GetLastError() == ERROR_BROKEN_PIPE){
    
51.                 printf("管道被子进程关闭\n");
    
52.         }else{
    
53.                 printf("读取数据错误，错误代码%d\n",GetLastError());
    
54.         }
    
55.         return 0;
    
56. }
    

复制代码

消息端

1. // Client.cpp : 定义控制台应用程序的入口点。
   
2. //
   
3. 
   
4. #include "stdafx.h"
   
5. #include <Windows.h>
   
6. #include <iostream>
   
7. using namespace std;
   
8. int _tmain(int argc, _TCHAR* argv[])
   
9. {
   
10.         for (int i = 0 ;i < 10 ; i++){
    
11.                 printf("i = %d;",i);
    
12.                 cout<<"标准输出"<<i<<endl;
    
13.                 cerr<<"标准错误"<<i<<endl;
    
14.         }
    
15.         system("pause");
    
16.         return 0;
    
17. }
    

复制代码

附上我的源码，希望有人可以帮助一下我。

freeparty

1. #include <windows.h>
   
2. #include <tchar.h>
   
3. #include <stdio.h>
   
4. #include <strsafe.h>
   
5. 
   
6. #define BUFSIZE 4096
   
7. 
   
8. HANDLE g_hChildStd_IN_Rd = NULL;
   
9. HANDLE g_hChildStd_IN_Wr = NULL;
   
10. HANDLE g_hChildStd_OUT_Rd = NULL;
    
11. HANDLE g_hChildStd_OUT_Wr = NULL;
    
12. 
    
13. HANDLE g_hInputFile = NULL;
    
14. 
    
15. void CreateChildProcess(void);
    
16. void WriteToPipe(void);
    
17. void ReadFromPipe(void);
    
18. void ErrorExit(PTSTR);
    
19. 
    
20. int _tmain(int argc, TCHAR *argv[])
    
21. {
    
22.    SECURITY_ATTRIBUTES saAttr;
    
23. 
    
24.    printf("\n->Start of parent execution.\n");
    
25. 
    
26. // Set the bInheritHandle flag so pipe handles are inherited.
    
27. 
    
28.    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    
29.    saAttr.bInheritHandle = TRUE;
    
30.    saAttr.lpSecurityDescriptor = NULL;
    
31. 
    
32. // Create a pipe for the child process's STDOUT.
    
33. 
    
34.    if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0) )
    
35.       ErrorExit(TEXT("StdoutRd CreatePipe"));
    
36. 
    
37. // Ensure the read handle to the pipe for STDOUT is not inherited.
    
38. 
    
39.    if ( ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
    
40.       ErrorExit(TEXT("Stdout SetHandleInformation"));
    
41. 
    
42. // Create a pipe for the child process's STDIN.
    
43. 
    
44.    if (! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
    
45.       ErrorExit(TEXT("Stdin CreatePipe"));
    
46. 
    
47. // Ensure the write handle to the pipe for STDIN is not inherited.
    
48. 
    
49.    if ( ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
    
50.       ErrorExit(TEXT("Stdin SetHandleInformation"));
    
51. 
    
52. // Create the child process.
    
53.    
    
54.    CreateChildProcess();
    
55. 
    
56. // Get a handle to an input file for the parent.
    
57. // This example assumes a plain text file and uses string output to verify data flow.
    
58. 
    
59.    if (argc == 1)
    
60.       ErrorExit(TEXT("Please specify an input file.\n"));
    
61. 
    
62.    g_hInputFile = CreateFile(
    
63.        argv[1],
    
64.        GENERIC_READ,
    
65.        0,
    
66.        NULL,
    
67.        OPEN_EXISTING,
    
68.        FILE_ATTRIBUTE_READONLY,
    
69.        NULL);
    
70. 
    
71.    if ( g_hInputFile == INVALID_HANDLE_VALUE )
    
72.       ErrorExit(TEXT("CreateFile"));
    
73. 
    
74. // Write to the pipe that is the standard input for a child process.
    
75. // Data is written to the pipe's buffers, so it is not necessary to wait
    
76. // until the child process is running before writing data.
    
77. 
    
78.    WriteToPipe();
    
79.    printf( "\n->Contents of %s written to child STDIN pipe.\n", argv[1]);
    
80. 
    
81. // Read from pipe that is the standard output for child process.
    
82. 
    
83.    printf( "\n->Contents of child process STDOUT:\n\n", argv[1]);
    
84.    ReadFromPipe();
    
85. 
    
86.    printf("\n->End of parent execution.\n");
    
87. 
    
88. // The remaining open handles are cleaned up when this process terminates.
    
89. // To avoid resource leaks in a larger application, close handles explicitly.
    
90. 
    
91.    return 0;
    
92. }
    
93. 
    
94. void CreateChildProcess()
    
95. // Create a child process that uses the previously created pipes for STDIN and STDOUT.
    
96. {
    
97.    TCHAR szCmdline[]=TEXT("child");
    
98.    PROCESS_INFORMATION piProcInfo;
    
99.    STARTUPINFO siStartInfo;
    
100.    BOOL bSuccess = FALSE;
     
101. 
     
102. // Set up members of the PROCESS_INFORMATION structure.
     
103. 
     
104.    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
     
105. 
     
106. // Set up members of the STARTUPINFO structure.
     
107. // This structure specifies the STDIN and STDOUT handles for redirection.
     
108. 
     
109.    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
     
110.    siStartInfo.cb = sizeof(STARTUPINFO);
     
111.    siStartInfo.hStdError = g_hChildStd_OUT_Wr;
     
112.    siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
     
113.    siStartInfo.hStdInput = g_hChildStd_IN_Rd;
     
114.    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
     
115. 
     
116. // Create the child process.
     
117.    
     
118.    bSuccess = CreateProcess(NULL,
     
119.       szCmdline,     // command line
     
120.       NULL,          // process security attributes
     
121.       NULL,          // primary thread security attributes
     
122.       TRUE,          // handles are inherited
     
123.       0,             // creation flags
     
124.       NULL,          // use parent's environment
     
125.       NULL,          // use parent's current directory
     
126.       &siStartInfo,  // STARTUPINFO pointer
     
127.       &piProcInfo);  // receives PROCESS_INFORMATION
     
128.    
     
129.    // If an error occurs, exit the application.
     
130.    if ( ! bSuccess )
     
131.       ErrorExit(TEXT("CreateProcess"));
     
132.    else
     
133.    {
     
134.       // Close handles to the child process and its primary thread.
     
135.       // Some applications might keep these handles to monitor the status
     
136.       // of the child process, for example.
     
137. 
     
138.       CloseHandle(piProcInfo.hProcess);
     
139.       CloseHandle(piProcInfo.hThread);
     
140.    }
     
141. }
     
142. 
     
143. void WriteToPipe(void)
     
144. 
     
145. // Read from a file and write its contents to the pipe for the child's STDIN.
     
146. // Stop when there is no more data.
     
147. {
     
148.    DWORD dwRead, dwWritten;
     
149.    CHAR chBuf[BUFSIZE];
     
150.    BOOL bSuccess = FALSE;
     
151. 
     
152.    for (;;)
     
153.    {
     
154.       bSuccess = ReadFile(g_hInputFile, chBuf, BUFSIZE, &dwRead, NULL);
     
155.       if ( ! bSuccess || dwRead == 0 ) break;
     
156.       
     
157.       bSuccess = WriteFile(g_hChildStd_IN_Wr, chBuf, dwRead, &dwWritten, NULL);
     
158.       if ( ! bSuccess ) break;
     
159.    }
     
160. 
     
161. // Close the pipe handle so the child process stops reading.
     
162. 
     
163.    if ( ! CloseHandle(g_hChildStd_IN_Wr) )
     
164.       ErrorExit(TEXT("StdInWr CloseHandle"));
     
165. }
     
166. 
     
167. void ReadFromPipe(void)
     
168. 
     
169. // Read output from the child process's pipe for STDOUT
     
170. // and write to the parent process's pipe for STDOUT.
     
171. // Stop when there is no more data.
     
172. {
     
173.    DWORD dwRead, dwWritten;
     
174.    CHAR chBuf[BUFSIZE];
     
175.    BOOL bSuccess = FALSE;
     
176.    HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     
177. 
     
178.    for (;;)
     
179.    {
     
180.       bSuccess = ReadFile( g_hChildStd_OUT_Rd, chBuf, BUFSIZE, &dwRead, NULL);
     
181.       if( ! bSuccess || dwRead == 0 ) break;
     
182. 
     
183.       bSuccess = WriteFile(hParentStdOut, chBuf,
     
184.                            dwRead, &dwWritten, NULL);
     
185.       if (! bSuccess ) break;
     
186.    }
     
187. }
     
188. 
     
189. void ErrorExit(PTSTR lpszFunction)
     
190. 
     
191. // Format a readable error message, display a message box,
     
192. // and exit from the application.
     
193. {
     
194.     LPVOID lpMsgBuf;
     
195.     LPVOID lpDisplayBuf;
     
196.     DWORD dw = GetLastError();
     
197. 
     
198.     FormatMessage(
     
199.         FORMAT_MESSAGE_ALLOCATE_BUFFER |
     
200.         FORMAT_MESSAGE_FROM_SYSTEM |
     
201.         FORMAT_MESSAGE_IGNORE_INSERTS,
     
202.         NULL,
     
203.         dw,
     
204.         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     
205.         (LPTSTR) &lpMsgBuf,
     
206.         0, NULL );
     
207. 
     
208.     lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
     
209.         (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR));
     
210.     StringCchPrintf((LPTSTR)lpDisplayBuf,
     
211.         LocalSize(lpDisplayBuf) / sizeof(TCHAR),
     
212.         TEXT("%s failed with error %d: %s"),
     
213.         lpszFunction, dw, lpMsgBuf);
     
214.     MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK);
     
215. 
     
216.     LocalFree(lpMsgBuf);
     
217.     LocalFree(lpDisplayBuf);
     
218.     ExitProcess(1);
     
219. }
     
220. 子进程文件
     
221. #include <windows.h>
     
222. #include <stdio.h>
     
223. 
     
224. #define BUFSIZE 4096
     
225. 
     
226. int main(void)
     
227. {
     
228.    CHAR chBuf[BUFSIZE];
     
229.    DWORD dwRead, dwWritten;
     
230.    HANDLE hStdin, hStdout;
     
231.    BOOL bSuccess;
     
232. 
     
233.    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
     
234.    hStdin = GetStdHandle(STD_INPUT_HANDLE);
     
235.    if (
     
236.        (hStdout == INVALID_HANDLE_VALUE) ||
     
237.        (hStdin == INVALID_HANDLE_VALUE)
     
238.       )
     
239.       ExitProcess(1);
     
240. 
     
241.    // Send something to this process's stdout using printf.
     
242.    printf("\n ** This is a message from the child process. ** \n");
     
243. 
     
244.    // This simple algorithm uses the existence of the pipes to control execution.
     
245.    // It relies on the pipe buffers to ensure that no data is lost.
     
246.    // Larger applications would use more advanced process control.
     
247. 
     
248.    for (;;)
     
249.    {
     
250.    // Read from standard input and stop on error or no data.
     
251.       bSuccess = ReadFile(hStdin, chBuf, BUFSIZE, &dwRead, NULL);
     
252.       
     
253.       if (! bSuccess || dwRead == 0)
     
254.          break;
     
255. 
     
256.    // Write to standard output and stop on error.
     
257.       bSuccess = WriteFile(hStdout, chBuf, dwRead, &dwWritten, NULL);
     
258.       
     
259.       if (! bSuccess)
     
260.          break;
     
261.    }
     
262.    return 0;
     
263. }
     

复制代码

我要去学校了，你先看

freeparty

正在给你写代码中，估计现在时间不够了，下午还要去学校呢。

康小泡

freeparty 发表于 2015-4-28 11:05
我要去学校了，你先看

辛苦江江了，我还得研究一下你的这个代码。昨天晚上去讨论比赛的事情去了。谢谢江江啦

shiba

学习

shiba

学习下

k2012

我只是路过打酱油的。

Ryans

哇~这个好！！！

y290176346

我是来领鱼币的