控制台进程重定向(Win32, C++)

已于 2024-03-01 22:12:58 修改
阅读量251 收藏 1
点赞数
分类专栏： Win32 文章标签： windows C++ Win32
于 2023-11-03 17:41:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Flame_Cyclone/article/details/134208161
版权
文章描述了一个C++类CConsoleHelper，用于运行Exe程序，支持命令行参数，以及控制输入输出、超时和错误处理。它通过管道机制管理子进程和通信。
摘要由CSDN通过智能技术生成

CConsoleHelper.h

#pragma once

#include <wtypesbase.h>
#include <string>
#include <vector>
#include <locale>
#include <tchar.h>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

class CConsoleHelper
{
public:
    CConsoleHelper();
    ~CConsoleHelper();

    //
    // @brief: 运行Exe程序
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    // @param: bNeedInput   是否需要输入内容
    // @param: bNeedOutput  是否需要输出内容
    // @ret: bool
    bool RunProcess(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T(""),
        bool bNeedInput = true,
        bool bNeedOutput = true
    );

    //
    // @brief: 运行Exe程序并获取其输出
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    // @param: dwTimeout  超时(毫秒)
    // @ret: _tstring 输出内容
    static _tstring RunProcessGetOutput(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T(""),
        DWORD dwTimeout = INFINITE
    );

    //
    // @brief: 运行Exe程序(可输入输出)
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    bool RunProcessWithInputOutput(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T("")
    );

    //
    // @brief: 运行Exe程序(仅输入)
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    bool RunProcessOnlyInput(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T("")
    );

    //
    // @brief: 运行Exe程序(仅输出)
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    bool RunProcessOnlyOutput(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T("")
    );

    //
    // @brief: 关闭
    // @ret: bool
    bool Close(void);

    //
    // @brief: 读取内容
    // @param: strContent  输出内容
    // @param: dwTimeout  超时(毫秒)
    // @ret: bool
    bool ReadOutput(_tstring& strContent, DWORD dwTimeout = INFINITE);

    //
    // @brief: 写入内容
    // @param: strContent   输入内容
    // @ret: bool
    bool WriteInput(const _tstring& strContent);

    //
    // @brief: 检测是否处于运行状态
    // @ret: bool
    bool IsRunning(void) const;

    //
    // @brief: 获取退出码
    // @ret: DWORD
    DWORD GetExitCode();

    // 
    // @brief: 获取文件所在文件夹
    // @param: strPath     文件名, 如: D:\Software\HxDPortableSetup.exe
    // @ret: 文件夹        如 D:\Software
    _tstring GetFileDir(const _tstring& strPath);

private:

    //
    // @brief: 运行Exe程序
    // @param: strExePath   可执行程序路径
    // @param: strCmd       命令行
    // @param: strCurDir    程序的当前路径
    // @param: bNeedInput   是否需要输入内容
    // @param: bNeedOutput  是否需要输出内容
    // @ret: bool
    bool _RunProcess(
        const _tstring& strExePath = _T(""),
        const _tstring& strCmd = _T(""),
        const _tstring& strCurDir = _T(""),
        bool bNeedInput = true,
        bool bNeedOutput = true
    );

    //宽字符转其他
    static std::string _WStrToOtherStr(UINT CodePage, const std::wstring& str);

    //其他转宽字符
    static std::wstring _OtherStrToWStr(UINT CodePage, const std::string& str);

    static _tstring _AStrToTStr(const std::string& str);
    static std::string _TStrToAStr(const _tstring& str);

private:
    HANDLE m_hPipeInWr;     //子进程输入写管道句柄
    HANDLE m_hPipeInRd;     //子进程输入读管道句柄
    HANDLE m_hPipeOutWr;    //子进程输出写管道句柄
    HANDLE m_hPipeOutRd;    //子进程输出读管道句柄
    PROCESS_INFORMATION m_childPI;  //控制台进程信息
};

CConsoleHelper.cpp

#include <strsafe.h>
#include "CConsoleHelper.h"

#define PIPE_READ_DATA_SIZE         (1024 * 1024)
#define PIPE_READ_TIME_INTERVAL     (50)

std::string CConsoleHelper::_WStrToOtherStr(UINT CodePage, const std::wstring& str)
{
    std::string strResult;
    LPSTR lpMultiByteStr = NULL;

    do
    {
        int nConverted = 0;

        //计算缓冲区所需的字节大小
        nConverted = ::WideCharToMultiByte(CodePage, 0, str.c_str(), -1, NULL, 0, NULL, NULL);
        if (0 == nConverted)
        {
            break;
        }

        //分配内存
        lpMultiByteStr = (LPSTR)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, nConverted);
        if (NULL == lpMultiByteStr)
        {
            break;
        }

        //转换
        nConverted = ::WideCharToMultiByte(CodePage, 0, str.c_str(), -1, lpMultiByteStr, nConverted, NULL, NULL);
        if (0 == nConverted)
        {
            break;
        }

        strResult = lpMultiByteStr;

    } while (false);

    //释放缓冲
    if (NULL != lpMultiByteStr)
    {
        ::HeapFree(::GetProcessHeap(), 0, lpMultiByteStr);
        lpMultiByteStr = NULL;
    }

    return strResult;
}

std::wstring CConsoleHelper::_OtherStrToWStr(UINT CodePage, const std::string& str)
{
    std::wstring strResult;
    LPWSTR lpWideStr = NULL;

    do
    {
        int nConverted = 0;

        //计算缓冲区所需的字节大小
        nConverted = ::MultiByteToWideChar(CodePage, 0, str.c_str(), -1, NULL, 0);
        if (0 == nConverted)
        {
            break;
        }

        //分配缓冲内存
        lpWideStr = (LPWSTR)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, nConverted * sizeof(WCHAR));
        if (NULL == lpWideStr)
        {
            break;
        }

        //转换字符串
        nConverted = ::MultiByteToWideChar(CodePage, 0, str.c_str(), -1, lpWideStr, nConverted);
        if (0 == nConverted)
        {
            break;
        }

        strResult = lpWideStr;

    } while (false);

    //释放缓冲
    if (NULL != lpWideStr)
    {
        ::HeapFree(::GetProcessHeap(), 0, lpWideStr);
        lpWideStr = NULL;
    }

    return strResult;
}

_tstring CConsoleHelper::_AStrToTStr(const std::string& str)
{
#ifdef _UNICODE
    return _OtherStrToWStr(CP_ACP, str);
#else
    return str;
#endif
}

std::string CConsoleHelper::_TStrToAStr(const _tstring& str)
{
#ifdef _UNICODE
    return _WStrToOtherStr(CP_ACP, str);
#else
    return str;
#endif
}

CConsoleHelper::CConsoleHelper()
    :
    m_hPipeInWr(NULL),
    m_hPipeInRd(NULL),
    m_hPipeOutWr(NULL),
    m_hPipeOutRd(NULL)
{
    ZeroMemory(&m_childPI, sizeof(m_childPI));
}

CConsoleHelper::~CConsoleHelper()
{
    Close();
}

bool CConsoleHelper::RunProcess(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/,
    bool bNeedInput/* = true*/,
    bool bNeedOutput/* = true*/
)
{
    return _RunProcess(strExePath, strCmd, strCurDir, bNeedInput, bNeedOutput);
}

bool CConsoleHelper::RunProcessWithInputOutput(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/
)
{
    return _RunProcess(strExePath, strCmd, strCurDir, true, true);
}

_tstring CConsoleHelper::RunProcessGetOutput(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/,
    DWORD dwTimeout/* = INFINITE*/
)
{
    CConsoleHelper Console;

    _tstring strContent;
    Console._RunProcess(strExePath, strCmd, strCurDir, false, true);
    Console.ReadOutput(strContent, dwTimeout);
    Console.Close();
    return strContent;
}

bool CConsoleHelper::RunProcessOnlyInput(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/
)
{
    return _RunProcess(strExePath, strCmd, strCurDir, true, false);
}

bool CConsoleHelper::RunProcessOnlyOutput(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/
)
{
    return _RunProcess(strExePath, strCmd, strCurDir, false, true);
}

bool CConsoleHelper::Close(void)
{
    ::CloseHandle(m_hPipeInWr);
    ::CloseHandle(m_hPipeInRd);
    ::CloseHandle(m_hPipeOutWr);
    ::CloseHandle(m_hPipeOutRd);
    m_hPipeInWr = NULL;
    m_hPipeInRd = NULL;
    m_hPipeOutWr = NULL;
    m_hPipeOutRd = NULL;

    if (IsRunning())
    {
        ::TerminateProcess(m_childPI.hProcess, (UINT)(-1));
        ::CloseHandle(m_childPI.hProcess);
        m_childPI.hProcess = NULL;
    }

    return true;
}

bool CConsoleHelper::ReadOutput(_tstring& strContent, DWORD dwTimeout/* = INFINITE*/)
{
    LPSTR lpReadBuf = NULL;
    strContent.clear();

    if (NULL == m_hPipeOutRd)
    {
        return false;
    }

    if (nullptr == lpReadBuf)
    {
        lpReadBuf = (char*)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, PIPE_READ_DATA_SIZE);
    }

    if (nullptr == lpReadBuf)
    {
        return false;
    }

    std::string strRead;
    DWORD readBytes = 0;
    ULONGLONG ullBegin = ::GetTickCount64();

    while (::PeekNamedPipe(m_hPipeOutRd, lpReadBuf, PIPE_READ_DATA_SIZE - 1, &readBytes, 0, NULL))
    {
        //未读取到数据则等待
        if (0 == readBytes)
        {
            //超时则退出
            if (INFINITE != dwTimeout && (::GetTickCount64() - ullBegin >= dwTimeout))
            {
                break;
            }

            ::Sleep(PIPE_READ_TIME_INTERVAL);
            continue;
        }

        if (::ReadFile(m_hPipeOutRd, lpReadBuf, PIPE_READ_DATA_SIZE - 1, &readBytes, NULL))
        {
            lpReadBuf[readBytes] = '\0';
            strRead += lpReadBuf;
        }
    }

    if (nullptr != lpReadBuf)
    {
        ::HeapFree(::GetProcessHeap(), 0, lpReadBuf);
        lpReadBuf = nullptr;
    }

    strContent = _AStrToTStr(strRead);

    return false;
}

bool CConsoleHelper::WriteInput(const _tstring& strContent)
{
    if (!IsRunning())
    {
        return false;
    }

    if (NULL == m_hPipeInRd)
    {
        return false;
    }

    std::string strWrite = _TStrToAStr(strContent);
    strWrite += "\r\n";

    DWORD writeBytes = 0;
    if (FALSE == ::WriteFile(m_hPipeInWr, strWrite.c_str(), (DWORD)strWrite.size(), &writeBytes, NULL))
    {
        return false;
    }

    return true;
}

bool CConsoleHelper::IsRunning(void) const
{
    DWORD dwExitCode = 0;

    if ((NULL != m_childPI.hProcess) &&
        (::GetExitCodeProcess(m_childPI.hProcess, &dwExitCode))
        )
    {
        return STILL_ACTIVE == dwExitCode;
    }

    return false;
}

DWORD CConsoleHelper::GetExitCode()
{
    DWORD dwExitCode = 0;

    if ((NULL != m_childPI.hProcess) &&
        (::GetExitCodeProcess(m_childPI.hProcess, &dwExitCode))
        )
    {
        return dwExitCode;
    }

    return (DWORD)-1;
}

_tstring CConsoleHelper::GetFileDir(const _tstring& strPath)
{
    _tstring strResult;
    size_t nIndex = strPath.find_last_of(_T('\\'));
    if (nIndex != _tstring::npos)
    {
        strResult = strPath.substr(0, nIndex);
    }

    return strResult;
}

bool CConsoleHelper::_RunProcess(
    const _tstring& strExePath/* = _T("")*/,
    const _tstring& strCmd/* = _T("")*/,
    const _tstring& strCurDir/* = _T("")*/,
    bool bNeedInput/* = true*/,
    bool bNeedOutput/* = true*/
)
{
    TCHAR szCmdBuf[MAX_PATH] = { 0 };
    SECURITY_ATTRIBUTES   sa = { 0 };
    STARTUPINFO si = { 0 };
    LPCTSTR lpCurrentDir = NULL;
    _tstring strExeCurrentDir = strCurDir;

    sa.bInheritHandle = TRUE;
    sa.lpSecurityDescriptor = NULL;
    sa.nLength = sizeof(sa);

    //创建子进程的标准输出管道
    if (!::CreatePipe(&m_hPipeOutRd, &m_hPipeOutWr, &sa, 0))
    {
        return false;
    }

    ::SetHandleInformation(m_hPipeOutRd, HANDLE_FLAG_INHERIT, 0);

    //创建子进程的标准输入管道
    if (!::CreatePipe(&m_hPipeInRd, &m_hPipeInWr, &sa, 0))
    {
        ::CloseHandle(m_hPipeInWr);
        ::CloseHandle(m_hPipeInRd);
        ::CloseHandle(m_hPipeOutWr);
        ::CloseHandle(m_hPipeOutRd);
        return false;
    }

    ::SetHandleInformation(m_hPipeInWr, HANDLE_FLAG_INHERIT, 0);

    si.cb = sizeof(STARTUPINFO);
    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;

    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    si.hStdOutput = GetStdHandle(STD_ERROR_HANDLE);

    if (bNeedInput)
    {
        si.hStdInput = m_hPipeInRd;
    }

    if (bNeedOutput)
    {
        si.hStdOutput = m_hPipeOutWr;
        si.hStdError = m_hPipeOutWr;
    }

    //exe路径不为空
    if (!strExePath.empty())
    {
        if (!strCmd.empty())
        {
            ::StringCchPrintf(szCmdBuf, _countof(szCmdBuf), _T("\"%s\" %s"), strExePath.c_str(), strCmd.c_str());
        }
        else
        {
            ::StringCchPrintf(szCmdBuf, _countof(szCmdBuf), _T("\"%s\""), strExePath.c_str());
        }
    }
    //exe路径为空
    else
    {
        ::StringCchPrintf(szCmdBuf, _countof(szCmdBuf), _T("%s"), strCmd.c_str());
    }

    //如果未指定进程当前目录, 则使用进程所在目录
    if (strExeCurrentDir.empty())
    {
        strExeCurrentDir = GetFileDir(strExePath);
    }

    if (!strExeCurrentDir.empty())
    {
        lpCurrentDir = strExeCurrentDir.c_str();
    }

    if (!::CreateProcess(NULL, szCmdBuf, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS, NULL, lpCurrentDir, &si, &m_childPI))
    {
        ::CloseHandle(m_hPipeInWr);
        ::CloseHandle(m_hPipeInRd);
        ::CloseHandle(m_hPipeOutWr);
        ::CloseHandle(m_hPipeOutRd);
        m_hPipeInWr = NULL;
        m_hPipeInRd = NULL;
        m_hPipeOutWr = NULL;
        m_hPipeOutRd = NULL;
        ZeroMemory(&m_childPI, sizeof(m_childPI));
        return false;
    }

    ::CloseHandle(m_childPI.hThread);
    m_childPI.hThread = NULL;

    return true;
}

 

 

Flame_Cyclone
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通用控制台重定向器
04-08
描述中提到的“从GUI应用程序启动控制台进程，甚至从Win9x接收其输出”，暗示了这种重定向器不仅适用于Windows NT系列操作系统（如WinXP、Win2K），还兼容较旧的Windows 95/98（Win9x）系统。控制台输出的接收表明该...
把控制台界面的显示重定向到文件
gfvjgggjkj的博客
09-01 961
import os import sys outer = sys.stdout file = open(“test1.txt”,’w’) help(“moudles”) sys.stdout.close() file = outer
控制台重定向
corn6的博客
12-27 1485
结构WNDCLASS包含一个窗口类的全部信息，也是Windows编程中使用的基本数据结构之一，应用程序通过定义一个窗口类确定窗口的属性 基本方法有： typedef struct _WNDCLASS { UINT style;// 窗口类型 WNDPROC lpfnWndProc;//窗口处理函数 int cbClsExtra;//窗口扩展 int cbWndExtra;//窗口实例扩展 HINSTANCE hInstance;//实例句柄 HICON hIcon;//窗口的最小化图标 .
win32程序执行控制台命令并重定向输出到文件
无忧老猪
08-28 8486
ShellExecute系列函数，可以执行控制台命令，但是无法实现输出重定向。 system函数，可以执行命令，并实现输出重定向，但是无法隐藏控制台窗口。 CreateProcess函数，则既可以执行命令，又可以实现输出重定向，同时不显示控制台窗口。 但是，CreateProcess函数的使用显得有些复杂。 我们可以将他包装一下，让他变得和ShellExecute或system一样好用。
Windows重定向技术【文件重定向与注册表重定向】
无
07-19 3446
Windows重定向技术【文件重定向、注册表重定向】
操作系统 实验7 控制台重定向
huanyuelanjin的博客
11-22 400
使用管道实现重定向功能。在程序中启动新的进程，在新进程中执行ping.exe 程序，使用管道技术将ping. exe的输出结果重定向到Windows的窗口中。在进程执行结束后，恢复系统默认的输入/输出。1、在 项目的属性页->高级->字符集 中，把字符集改为“未设置”2、在项目的属性页->C/C++->语言->符合模式 中，改为“否”在项目属性页->系统->子系统中，把子系统设置为“窗口”按照这个错误提示把strcat改为 strcat_s。3、接着出现下面问题。
[ARM 汇编]进阶篇—异常处理与中断—2.4.4 重定向异常处理程序
Andy0214的专栏
06-16 5911
有时我们需要在运行时动态更改异常处理程序的地址。这种情况下，我们可以使用重定向异常处理程序的技术。本节将介绍重定向异常处理程序的基本概念、原理以及如何实现。
创建基于控制台的调试窗口
04-11
默认情况下，C++的Win32和MFC应用程序创建的是无控制台的进程。如果我们想要在这些进程中添加控制台，我们需要调用Windows API函数来实现。 1. **创建控制台窗口** 要为一个无控制台的进程创建控制台，可以使用`...
重定向任意控制台的输入/输出
04-11
如果要重定向其他进程的控制台I/O，我们需要利用Windows API。`CreateProcess()`函数允许创建新进程，并指定其标准输入、输出和错误的句柄。例如，以下代码片段将新进程的输出连接到当前控制台： ```cpp ...
It-is-a-hooktest-programAPI.rar_钩子与API截获_Visual_C++_
08-12
1. **创建项目**：首先，你需要在Visual C++中创建一个新的Win32控制台或MFC应用程序项目。 2. **导入库和头文件**：为了使用钩子和API截获，你可能需要导入如`Windows.h`、`User32.dll`等相关的头文件和库。 3. *...
从零开始的代码重定位--一个小实例
李辉的博客
11-18 872
从零开始的代码重定位--一个小实例                                     ---参考朱有鹏ARM裸机编程 1、任务： 在SRAM中将代码从0xd0020010重定位到0xd0024000 如果创造这个环境？ 把程序下载到0xd0020010，但是在链接脚本把其我们想让其链接到0xd0024000 代码实际运行在0xd0020010,但是被链接到0xd0
Heart.EXE注入函数完整过程及分析总结（图15个，涉及函数重定向，函数参数等问题，不是运行时注入，是在EXE文件中注入函数）
贺昌锋的博客,， 西安，陕西，Chang Feng He
10-26 1666
Heart执行文件EXE函数注入完整过程（图15个，设计函数重定向，函数参数等问题） **微软红桃大战游戏heart.exe，我拷贝为D.EXE，运行后先弹出自己的一个对话框，然后再正常游戏。几乎花了我2周的时间，从头到尾。这只是后面一部分。涉及到DLL函数的重定位，函数参数的相对地址，PE文件的结构。声明一下，我是在WIN 7 + Intel 赛扬32位上破解注入成功的。 我信奉动手做，之说...
C++ Primer 第五版文件重定向具体操作方法
weixin_57527004的博客
07-18 217
C++ Primer 第五版文件重定向具体操作方法
C语言重定向输出入（windows命令行）
最新发布
2301_79140115的博客
08-23 192
cmd调出命令行，找到文件相应硬盘。首先确保两文件均在一个文件夹。再确定exe文件是否可用。输入文件全称及相应命令。
嵌入式linux学习笔记--控制台的数据重定向 以及 进程打印 数据的重定向
jeason的博客
11-04 1080
记录一下今天的收获，项目上的一个需求是将嵌入式平台内的所有的打印信息输出到一个统一的地方，方便管理，为了实现这种需求 我一共尝试了几种方案，记录一下。 1 . 需求1 嵌入式设备的串口打印信息转移到另一个控制台 这种需求是因为产品的串口默认是不引出的，平时对产品进行调试的时候免不了需要去查看串口信息，那么 我们自然就希望将原本的串口控制台的输出信息转移到当前的通用ssh 登录的控制台。 相关的代码的实现如下： #include <stdio.h> #include <stdlib.h&gt
Windows下实现控制台程序输出重定向到其他进程(iperf为例)
CAIKAIKAI1的博客
09-19 2128
本篇文章主要介绍windows下如何将一个应用程序的输出重定向到另一个进程中，主要原理是通过匿名管道实现进程信息的重定向。 工作中有时会遇到这样一个场景，应用程序A.exe需要调用应用程序B.exe进行一些辅助性操作，同时，A还需要获取B执行后的输出结果，以便于在A中根据B的输出结果进行相关的操作。本文主要解决的就是上述问题。以iperf为例，iperf是一个网络吞吐量测试工具，它可以测试当前的...
Linux控制台重定向方法及原理
勤学如春起之苗，不见其增，日有所长！ 辍学如磨刀之石，不见其损，日有所亏！
10-28 1754
Linux控制台重定向方法 本文介绍一种通过文件描述符重定向终端输入/输出的方法。 一、背景 一些嵌入式设备，一般都会留有调试串口，经由RS232/485标准与PC的COM口相连，将打印输出在PC上显示，并可以接收PC端的输入，如下图所示： 设备出厂部署后，不方便接调试串口，查看设备输出就变得比较困难，不利于问题定位。 如果设备具有联网能力，我们可以通过telnet或者ssh登录到设备上，进行远程调试。 这时候就面临一个问题：如何把设备的打印信息显示出来？ 常见做法有以下几种...
控制台重定向stdout & stderr
热门推荐
ce123的技术博客
07-30 1万+
控制台重定向stdout & stderr 通常，从一个控制台（命令提示符）应用程序或命令的输出将发送到两个单独的流。在常规的输出发送到标准出 (stdout) 并将错误消息发送到标准错误 （stderr）。当你重定向控制台输出使用">"符号，只重定向标准输出。要重定向stderr，必须指定"2 >"的重定向符号。这将选择第二个输出流stderr。示例$ kill -HUP 1234 >killo
「操作系统」实验7「控制台重定向」
新橙
11-30 462
由于这里是windows编程，所以踩了比较多的坑… 代码都是照着图片敲的，100多来行吧… 代码这里只给图片了， 需要的私聊吧 。(拒绝偷懒) 坑1：主函数路口 前言：由于是windows编程，因此新建窗口的时候的主函数为WINAPI WinMain，没有主函数。然后我新建的是控制台应用程序，所以必须需要main函数才能运行成功。这里要用到两行代码，如下（能成功运行）： // 如果创建的项目类型是“控制台应用程序”，可以添加下面两条预编译指令 // 第一条的意思是程序入口点是WinMainCRTSta
c++ win32 控制台托盘
08-12
Win32控制台托盘是一种用于在Windows操作系统中的控制台应用程序中添加托盘图标的技术。 Win32是一种面向Windows平台的编程技术。它提供了一套应用程序编程接口（API），开发人员可以使用这些接口来创建和管理Windows应用程序。使用Win32编程技术，开发人员可以通过编写C语言或C++代码来实现控制台应用程序。 控制台应用程序是一种以命令行界面为基础的应用程序，通常通过命令行窗口来操作和显示结果。然而，控制台应用程序通常不支持图形用户界面（GUI）的特性，例如窗口和图标。 然而，通过使用Win32控制台托盘技术，开发人员可以在控制台应用程序中添加托盘图标。托盘图标通常显示在任务栏的系统托盘区域，提供快速访问应用程序的功能。 要实现Win32控制台托盘，开发人员需要使用Win32 API中的相关函数和消息。例如，可以使用Shell_NotifyIcon函数来添加、修改或删除托盘图标，使用Shell_NotifyIcon消息来处理托盘图标的操作和事件。 使用Win32控制台托盘技术，开发人员可以为控制台应用程序添加更多的交互性和易用性。用户可以通过右击托盘图标来打开菜单，执行一些预定义的操作，例如显示控制台窗口、关闭应用程序等。 总而言之，Win32控制台托盘是一种在控制台应用程序中实现托盘图标的技术。通过使用相关的Win32 API函数和消息，开发人员可以为控制台应用程序添加更多的用户交互性和易用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值