STDOUT和STDERR，以及它们的重定向

最新推荐文章于 2023-08-29 12:33:54 发布
最新推荐文章于 2023-08-29 12:33:54 发布
阅读量2.2k 收藏 2
点赞数 1
分类专栏： 杂项 文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DongAoTony/article/details/123949602
版权

它们都是Linux系统的标准文件

在Linux系统中，有3个标准的文件，它们分别占据了文件编号：

  1. 0，STDIN，标准输入文件。
  2. 1，STDOUT，标准输出文件。
  3. 2，STDERR，标准错误文件。

它们仨在Linux系统中，都会有着具体的文件描述符限定着它们的特性，都对应着特定的输入输出设备：
img

其中，STDOUT与STDERR都会对应着输出设备，而且如果不重定向的话，它们的输出都会输出到屏幕（在Linux系统中，就是一种FrameBuffer的设备），所以有不少人容易把它们搞混。

STDOUT与STDERR的区别

我们应看到，它俩主要有两份点不同：

  1. 如果指定了输出是某个文件，则STDOUT的输出会到这个文件，而STDERR仍然继续输出到屏幕。
  2. STDOUT是行缓冲的，也就是只有有换行符时，其上的内容才会到指定的文件（不管是屏幕这个设备文件，还是其它的一般文件）；而STDERR则不会有缓冲，所以有字节内容，它就会输出。

下面一段C的代码，大家可以试Run一下，来感受STDOUT缺省输出与重定向后的区别：


                

                
                
        

        

    




        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  DongAoTony
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
1、stderr与stdout的区别

				
			

			

				

					sxj731533730
				

				

					06-20
					
					5183
					
				

			

		

		

			
				
介绍一下：stdout, stdin, stderr的区别；
stdout, stdin, stderr的中文名字分别是标准输出，标准输入和标准错误。当一个用户进程被创建的时候，系统会自动为该进程创建三个数据流， 一个程序要运行，需要有输入、输出，如果出错，还要能表现出自身的错误。这是就要从某个地方读入数据、将数据输出到某个地方，这就够成了数据流。因此，一个进程初期所拥有的这么三个数据流，就分别是标

			
		

	



                

              
                



	

		

			

				
					
Go-websocketd把命令行的输出stdout和stderr重定向为一个websocket服务的工具

				
			

			

				

					08-14
				

			

		

		

			
				
本文将深入探讨名为`websocketd`的工具，这是一个用Go语言开发的小型命令行工具，它能将任何命令行程序的输出（stdout和stderr）实时地通过WebSocket服务进行传输。  首先，让我们理解`websocketd`的工作原理。`...

			
		

	



                


  
              

                


	

		

			

				
					
stdout和stderr重定向

				
			

			

				

					MyCyber
				

				

					08-16
					
					8407
					
				

			

		

		

			
				
stdout和stderr的重定向C语言中对应于显示器的指针有两个：stdout和stderr。书上说，对于前者，信息输出时总是先送入缓冲区（行间缓存），然后再输出到屏幕；而对后者，信息是不经过缓冲区直接输入到屏幕的。因此，向stdout输出的信息是可以被重定向的，输出到stderr的信息则不能被重定向。但是我认为输出到stderr的信息也是可以被重定向的。下面举例说明：#include <stdi

			
		

	





	

		

			

				
					
C++——输入输出(stdin，stdout和stderr)、const与指针、const与引用相关问题

				
			

			

				

					Singularitys123的博客
				

				

					02-10
					
					7727
					
				

			

		

		

			
				
C++中的输入输出（stdin,stdout和stderr）const与指针、const与引用相关问题

			
		

	



		

			
		



	

		

			

				
					
Linux多进程开发(三)

				
			

			

				

					STATEABC的博客
				

				

					06-20
					
					279
					
				

			

		

		

			
				
进程间通信

			
		

	





	

		

			

				
					
C语言stdout，stdin流介绍

					
热门推荐

				
			

			

				

					Mr.nie的博客
				

				

					08-08
					
					1万+
					
				

			

		

		

			
				
stdout,stdin, stderr是一个C程序中默认开启的三个数据流（文章只介绍stdout， stdin.）stdout -- 标准输出流 -- 屏幕stdin -- 标准输入流 -- 键盘stderr -- 标准错误流 -- 屏幕我们写程序时，有时想把数据输出到屏幕上，有时想把数据输出到硬盘上，有时候想把数据输出到软盘上，有时想把数据输出到光盘上...所以我们在写程序的时候会经常操控各种各样的硬件，硬件的不同，读写方式也不同，所以我们难道要懂得各种各样硬件的读写方式吗。...

			
		

	





	

		

			

				
					
linux stdout日志,K8S 日志为什么以 stdout 和 stderr 的方式输出？

				
			

			

				

					weixin_34409903的博客
				

				

					05-11
					
					1155
					
				

			

		

		

			
				
1. 什么是 stdout 和 stderr ?在linux系统中，当我们创建一个进程，默认会创建3个文件：进程的文件描述符列表文件描述符          作用                 例子(c语言)0  (stdin)        标准输入             fscanf...

			
		

	





	

		

			

				
					
解析c中stdout与stderr容易忽视的一些细节

				
			

			

				

					09-05
				

			

		

		

			
				
总之，理解并熟练掌握 `stdout` 和 `stderr` 的缓冲机制以及它们在重定向和调试场景中的行为，是编写高质量C程序的重要一环。适时使用 `fflush()`、`setbuf()` 或 `setvbuf()`，以及合理选择使用stdio流还是文件描述...

			
		

	





	

		

			

				
					
Windows管道(Pipe)重定向stdout,stderr,stdin

				
			

			

				

					07-07
				

			

		

		

			
				
有时我们需要重定向stdout,stderr,stdin。比如：将输出写入文件，又或者我们要将命令行程序输出结果显示到Windows对话框中。源码示范如何在Windows中实现，封装了几个简单易用的函数。

			
		

	





	

		

			

				
					
检查stdout或stderr是否是交互式的-Node.js开发

				
			

			

				

					05-27
				

			

		

		

			
				
is-interactive检查stdout或stderr是否是交互式的它检查流是否为TTY，而不是哑终端，并且不在CI中运行。
这对于决定是否在交互式交互中呈现交互式UI或动画很有用。检查stdout或stderr是否是交互式的。它检查流是TTY，而不是哑终端，并且不在CI中运行。
这对于决定是在终端中呈现交互式UI还是动画很有用。
安装$ npm install is-interactive用法const isInteractive = require（'is-interactive'）;
isInteractive（）;
// => true API isInteractive（options？）options类型：对象流类型：stream.Writable默认值：process.stdout要检查的流。



			
		

	





	

		

			

				
					
Node.js检查stdout或stderr是否是交互式的

				
			

			

				

					08-09
				

			

		

		

			
				
总结来说，检查`stdout`或`stderr`是否是交互式的关键在于使用`process.stdout.isTTY`和`process.stderr.isTTY`属性，以及在必要时引入第三方库如`sindresorhus/is-interactive`来确保跨平台兼容性。理解这一点对于...

			
		

	





	

		

			

				
					
tty-command：执行带有漂亮输出日志记录的shell命令，并捕获stdout，stderr和退出状态

				
			

			

				

					01-30
				

			

		

		

			
				
 将每个命令的stdin，stdout和stderr重定向到文件或字符串。 TTY :: Command为工具包提供了独立的命令执行组件。动机复杂的软件项目不仅仅是一个应用程序。 这些项目通常会产生数十个或数百个补充的独立脚本，这些...

			
		

	





	

		

			

				
					
syslog-redirector:将 stdinstderr 重定向到 syslog

				
			

			

				

					06-02
				

			

		

		

			
				
一种静态编译工具，用于生成可执行文件，将其标准输出和标准错误重定向到 syslog。  静态编译很重要，至少在预期的 Helios/Docker 用例中，因为我们不想对容器的内容以及 libc 的可用性或位置做出任何假设。 具体来...

			
		

	





	

		

			

				
					
详解python的几种标准输出重定向方式

				
			

			

				

					09-21
				

			

		

		

			
				
`sys.stdin`、`sys.stdout`和`sys.stderr`是Python解释器与外界交互的三个重要对象。它们分别代表标准输入（用户输入）、标准输出（程序正常输出）和标准错误（程序异常输出）。在程序启动时，`sys.__stdin__`、`sys...

			
		

	





	

		

			

				
					
Linux- 重定向标准输出（stdout）和标准错误（stderr）

					
最新发布

				
			

			

				

					青衫客36的博客
				

				

					08-29
					
					3349
					
				

			

		

		

			
				
在Linux或Unix系统中，你可以通过重定向标准输出（stdout）和标准错误（stderr）来将脚本的输出保存到一个文件中。说的是：“将标准错误（文件描述符2）重定向到与标准输出（文件描述符1）相同的地方。这将捕获正常的输出（stdout）和错误消息（stderr），并将它们都写入。这将只捕获正常的输出（stdout），但不包括错误消息（stderr）。是用来重定向标准错误（stderr）到标准输出（stdout）的。将标准错误也重定向到标准输出所指向的相同的文件。文件的末尾追加新的输出和错误消息。

			
		

	





	

		

			

				
					
stderr/stdout用法

				
			

			

				

					西北工业大学的博客
				

				

					08-26
					
					1679
					
				

			

		

		

			
				
【unix】标准输出(设备)文件，对应终端的屏幕。进程将从标准输入文件中得到输入数据，将正常输出数据输出到标准输出文件，而将错误信息送到标准错误文件中。在C中，程序执行时，一直处于开启状态。 
与其有关的 stdin、stdout……

可能的使用方法有：fprintf(stderr,”error message”) 
stderr – 标准错误输出设备 
stdout – 标准输出设备 (pri...

			
		

	





	

		

			

				
					
linux程序 stdout stderr 重定向问题

				
			

			

				

					Terminator的专栏
				

				

					01-19
					
					2080
					
				

			

		

		

			
				
linux 应用程序 stderr stdout 输出到指定目录

			
		

	





	

		

			

				
					
qt wifi mesh 中节点自组网代码

				
			

			

				

					05-14
				

			

		

		

			
				
以下是一个基于 Qt 的 WiFi Mesh 自组网示例代码：

```cpp
#include <QCoreApplication>
#include <QNetworkConfigurationManager>
#include <QNetworkSession>
#include <QProcess>
#include <QTimer>
#include <QSocketNotifier>
#include <QDebug>

// WiFi Mesh 自组网示例代码

#define CONFIG_FILE "/etc/wpa_supplicant.conf"
#define CONFIG_TEMPLATE "ctrl_interface=/var/run/wpa_supplicant\n\
update_config=1\n\
\n\
network={\n\
    ssid=\"%1\"\n\
    mode=1\n\
    frequency=2412\n\
    proto=RSN\n\
    key_mgmt=WPA-PSK\n\
    pairwise=CCMP\n\
    group=CCMP\n\
    psk=\"%2\"\n\
}"

class Node : public QObject
{
    Q_OBJECT
public:
    Node(const QString& name, const QString& ssid, const QString& password);

public slots:
    void start();
    void stop();

private slots:
    void readStdout();
    void readStderr();
    void processError(QProcess::ProcessError error);
    void processFinished(int exitCode, QProcess::ExitStatus exitStatus);
    void networkSessionOpened();
    void networkSessionClosed();
    void socketActivated(int fd);

private:
    QString m_name;
    QString m_ssid;
    QString m_password;
    QString m_configFilePath;
    QProcess m_process;
    QNetworkConfigurationManager m_networkConfigManager;
    QNetworkSession* m_networkSession;
    QTimer m_timer;
    QSocketNotifier* m_socketNotifier;
};

Node::Node(const QString& name, const QString& ssid, const QString& password)
    : QObject(nullptr)
    , m_name(name)
    , m_ssid(ssid)
    , m_password(password)
    , m_configFilePath(QString("/etc/wpa_supplicant-%1.conf").arg(name))
    , m_process(this)
    , m_networkConfigManager(this)
    , m_networkSession(nullptr)
    , m_timer(this)
    , m_socketNotifier(nullptr)
{
    connect(&m_process, &QProcess::readyReadStandardOutput, this, &Node::readStdout);
    connect(&m_process, &QProcess::readyReadStandardError, this, &Node::readStderr);
    connect(&m_process, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &Node::processFinished);
    connect(&m_process, &QProcess::errorOccurred, this, &Node::processError);
    connect(&m_networkConfigManager, &QNetworkConfigurationManager::onlineStateChanged, this, &Node::networkSessionClosed);
    connect(&m_timer, &QTimer::timeout, this, &Node::start);
}

void Node::start()
{
    if (m_networkSession && m_networkSession->isOpen()) {
        qDebug() << "Node" << m_name << "is already connected to the network";
        return;
    }

    qDebug() << "Starting node" << m_name << "...";

    // Write the configuration file for this node
    QFile configFile(m_configFilePath);
    if (configFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
        QTextStream out(&configFile);
        out << QString(CONFIG_TEMPLATE).arg(m_ssid).arg(m_password);
        configFile.close();
    } else {
        qCritical() << "Error writing configuration file for node" << m_name;
        return;
    }

    // Start the wpa_supplicant process
    QStringList arguments;
    arguments << "-Dnl80211" << "-c" << m_configFilePath;
    m_process.start("wpa_supplicant", arguments);

    // Wait for the process to start and create the control socket
    if (m_process.waitForStarted()) {
        m_socketNotifier = new QSocketNotifier(m_process.handle(), QSocketNotifier::Read, this);
        connect(m_socketNotifier, &QSocketNotifier::activated, this, &Node::socketActivated);
    } else {
        qCritical() << "Error starting wpa_supplicant for node" << m_name;
    }

    // Wait for the network session to be opened
    if (!m_networkSession) {
        m_networkSession = new QNetworkSession(m_networkConfigManager.defaultConfiguration(), this);
        connect(m_networkSession, &QNetworkSession::opened, this, &Node::networkSessionOpened);
        connect(m_networkSession, &QNetworkSession::closed, this, &Node::networkSessionClosed);
    } else {
        networkSessionOpened();
    }
}

void Node::stop()
{
    qDebug() << "Stopping node" << m_name << "...";

    // Stop the wpa_supplicant process
    m_process.terminate();
    if (!m_process.waitForFinished(5000)) {
        m_process.kill();
    }

    // Delete the configuration file for this node
    QFile::remove(m_configFilePath);

    // Close the network session
    if (m_networkSession) {
        m_networkSession->close();
    }
}

void Node::readStdout()
{
    qDebug() << "Node" << m_name << "stdout:" << m_process.readAllStandardOutput();
}

void Node::readStderr()
{
    qWarning() << "Node" << m_name << "stderr:" << m_process.readAllStandardError();
}

void Node::processError(QProcess::ProcessError error)
{
    qCritical() << "Node" << m_name << "process error:" << error << m_process.errorString();
}

void Node::processFinished(int exitCode, QProcess::ExitStatus exitStatus)
{
    qDebug() << "Node" << m_name << "process finished with exit code" << exitCode << "and exit status" << exitStatus;
}

void Node::networkSessionOpened()
{
    qDebug() << "Node" << m_name << "network session opened:" << m_networkSession->isOpen();
}

void Node::networkSessionClosed()
{
    qDebug() << "Node" << m_name << "network session closed:" << !m_networkSession->isOpen();
    m_networkSession = nullptr;
    m_socketNotifier = nullptr;
    m_timer.start(1000);
}

void Node::socketActivated(int fd)
{
    char buffer[1024];
    int length = read(fd, buffer, sizeof(buffer));
    if (length > 0) {
        qDebug() << "Node" << m_name << "control socket message:" << QString::fromUtf8(buffer, length);
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // Start the nodes
    Node node1("node1", "mesh", "password");
    Node node2("node2", "mesh", "password");
    Node node3("node3", "mesh", "password");
    node1.start();
    node2.start();
    node3.start();

    // Stop the nodes after 10 seconds
    QTimer::singleShot(10000, &node1, &Node::stop);
    QTimer::singleShot(10000, &node2, &Node::stop);
    QTimer::singleShot(10000, &node3, &Node::stop);

    return a.exec();
}

#include "main.moc"
```

在上面的示例代码中，我们定义了一个 Node 类，它代表一个 WiFi Mesh 网络中的节点。在 Node 类的构造函数中，我们传入了节点的名称、SSID 和密码，同时生成了一个节点专用的 wpa_supplicant 配置文件。在 Node 类的 start() 方法中，我们启动了 wpa_supplicant 进程，并且等待它创建控制套接字。我们还创建了一个 QNetworkSession 对象，用于连接到 WiFi 网络，等待连接成功后，我们就可以使用这个节点了。在 Node 类的 stop() 方法中，我们停止了 wpa_supplicant 进程，并且删除了节点专用的 wpa_supplicant 配置文件。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
DongAoTony

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值