重定向共享库输出 我使用C++，所以JNA。当我通过NETBeNes运行时，C++ CUT的输出直接打印在NETBeS控制台中。问题是，我想将这个输出重定向到一个JFrame。正如我在web上找到的其他类似主题所建议的，我使用freopen（）将stdout重定向到一个文件。它工作的很好，但我有一个问题，这个解决方案。只要C++代码已经停止（或者至少我理解了——也许我错了），数据可以被读取，然后重定向到JFrrar。所以我想问一下，有没有真正的方法来重定向C++的输出，可以从java代码中实时访问？我是指在C++代码执行期间，而不是在C++部分结束操作之后。谢谢。

哦，上帝。。重定向到管道是我能想到的最糟糕的主意之一。。将其写入文件，然后将其读入，甚至比这更糟糕

它不符合您对“实时”或“实时”数据的要求

这些选项只能在“C”中使用，而不能在“C++”中使用。。C++有更好的方法来做你想做的事情…< /P> 您可以做的是创建自己的流，通过JNI调用直接写入您想要的任何地方。。首先需要从

std:：streambuf

继承，然后从定制类创建

std:：ostream

将

std:：cout

的rdbuf重定向到自定义流

以下是我写的：

#include "jni.h"

#include <tuple>
#include <vector>
#include <iostream>
#include <cstring>

#if defined _WIN32 || defined _WIN64
#include <windows.h>
#else
#include <sys/types.h>
#endif

#if defined _WIN32 || defined _WIN64
#define JAVA_EXPORT __declspec(dllexport)
#else
#define JAVA_EXPORT
#endif


std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>> streams;

extern "C" {
    JAVA_EXPORT void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component);
    JAVA_EXPORT void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls);
}

class redir : public std::streambuf
{
    private:
        JNIEnv* env;
        jobject comp;
        jmethodID mID;

        int_type overflow(int_type c  = traits_type::eof());

    public:
        redir(JNIEnv* e, jobject comp, jmethodID m) : env(env), comp(comp), mID(mID) {}
        ~redir() {}

        redir(const redir& other) = delete;
        redir& operator = (const redir& other) = delete;
};

redir::int_type redir::overflow(redir::int_type c)
{
    if (c != traits_type::eof())
    {
        jstring str = env->NewStringUTF((char*)&c);
        env->CallVoidMethod(comp, mID, str);
    }

    return c;
}

class rdstream : public std::ostream
{
    public:
        rdstream(JNIEnv* env, jobject comp, jmethodID mID) : std::ostream(0), sbuf(env, comp, mID) {init(&sbuf);}

    private:
        redir sbuf;
};



void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component)
{
    if (streams.empty())
    {
        jclass txtcls = env->FindClass("Ljavax/swing/JTextArea;");

        if (txtcls)
        {
            jmethodID app = env->GetMethodID(txtcls, "append", "(Ljava/lang/String;)V");

            rdstream* ctrd = new rdstream(env, component, app);
            rdstream* crrd = new rdstream(env, component, app);
            streams.push_back(std::make_tuple(ctrd, &std::cout, std::cout.rdbuf()));
            streams.push_back(std::make_tuple(crrd, &std::cerr, std::cerr.rdbuf()));
            std::cout.rdbuf(ctrd->rdbuf());
            std::cerr.rdbuf(crrd->rdbuf());

            std::cout<<"TESTING OUTPUT REDIRECTION\n";
        }
    }
}

void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls)
{
    for (std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>>::iterator it = streams.begin(); it != streams.end(); ++it)
    {
        std::get<1>(*it)->rdbuf(std::get<2>(*it));
        delete std::get<0>(*it);
    }

    streams.clear();

    std::cout<<"TESTING OUTPUT RESET\n"<<std::flush;
}

void __attribute__((constructor)) load()
{
    //Onload..
}

void __attribute__((destructor)) unload()
{
    //OnUnload..
    if (!streams.empty())
    {
        Java_natives_Natives_ResetOutput(NULL, NULL);
    }
}

和一个测试类：

package windowhandle;

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author Brandon
 */
public class WindowHandle {

    public static void main(String[] args) {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);

        JTextArea t = new JTextArea();
        t.setPreferredSize(new Dimension(500, 100));
        f.setLayout(new BorderLayout(0, 0));
        f.getContentPane().add(t, BorderLayout.CENTER);
        f.pack();

        natives.Natives.RedirectOutput(t);        
        natives.Natives.ResetOutput();
    }
}

现在C++代码可以按你喜欢的方式定制。您可以在java端上创建一个方法，该方法附加到您想要的任何组件，然后让C++调用它，而不是查找文本区域并具体地附加到它。如果您这样做，那么它可以用于任何项目和任何组件，而不仅仅是文本区域

这甚至可以用于文件（

std:：fstream

）

无论如何。。结果是：

当您重定向它时：

重置时：

---

哦，上帝。。重定向到管道是我能想到的最糟糕的主意之一。。将其写入文件，然后将其读入，甚至比这更糟糕

它不符合您对“实时”或“实时”数据的要求

这些选项只能在“C”中使用，而不能在“C++”中使用。。C++有更好的方法来做你想做的事情…< /P> 您可以做的是创建自己的流，通过JNI调用直接写入您想要的任何地方。。首先需要从

std:：streambuf

继承，然后从定制类创建

std:：ostream

将

std:：cout

的rdbuf重定向到自定义流

以下是我写的：

#include "jni.h"

#include <tuple>
#include <vector>
#include <iostream>
#include <cstring>

#if defined _WIN32 || defined _WIN64
#include <windows.h>
#else
#include <sys/types.h>
#endif

#if defined _WIN32 || defined _WIN64
#define JAVA_EXPORT __declspec(dllexport)
#else
#define JAVA_EXPORT
#endif


std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>> streams;

extern "C" {
    JAVA_EXPORT void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component);
    JAVA_EXPORT void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls);
}

class redir : public std::streambuf
{
    private:
        JNIEnv* env;
        jobject comp;
        jmethodID mID;

        int_type overflow(int_type c  = traits_type::eof());

    public:
        redir(JNIEnv* e, jobject comp, jmethodID m) : env(env), comp(comp), mID(mID) {}
        ~redir() {}

        redir(const redir& other) = delete;
        redir& operator = (const redir& other) = delete;
};

redir::int_type redir::overflow(redir::int_type c)
{
    if (c != traits_type::eof())
    {
        jstring str = env->NewStringUTF((char*)&c);
        env->CallVoidMethod(comp, mID, str);
    }

    return c;
}

class rdstream : public std::ostream
{
    public:
        rdstream(JNIEnv* env, jobject comp, jmethodID mID) : std::ostream(0), sbuf(env, comp, mID) {init(&sbuf);}

    private:
        redir sbuf;
};



void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component)
{
    if (streams.empty())
    {
        jclass txtcls = env->FindClass("Ljavax/swing/JTextArea;");

        if (txtcls)
        {
            jmethodID app = env->GetMethodID(txtcls, "append", "(Ljava/lang/String;)V");

            rdstream* ctrd = new rdstream(env, component, app);
            rdstream* crrd = new rdstream(env, component, app);
            streams.push_back(std::make_tuple(ctrd, &std::cout, std::cout.rdbuf()));
            streams.push_back(std::make_tuple(crrd, &std::cerr, std::cerr.rdbuf()));
            std::cout.rdbuf(ctrd->rdbuf());
            std::cerr.rdbuf(crrd->rdbuf());

            std::cout<<"TESTING OUTPUT REDIRECTION\n";
        }
    }
}

void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls)
{
    for (std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>>::iterator it = streams.begin(); it != streams.end(); ++it)
    {
        std::get<1>(*it)->rdbuf(std::get<2>(*it));
        delete std::get<0>(*it);
    }

    streams.clear();

    std::cout<<"TESTING OUTPUT RESET\n"<<std::flush;
}

void __attribute__((constructor)) load()
{
    //Onload..
}

void __attribute__((destructor)) unload()
{
    //OnUnload..
    if (!streams.empty())
    {
        Java_natives_Natives_ResetOutput(NULL, NULL);
    }
}

和一个测试类：

package windowhandle;

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author Brandon
 */
public class WindowHandle {

    public static void main(String[] args) {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);

        JTextArea t = new JTextArea();
        t.setPreferredSize(new Dimension(500, 100));
        f.setLayout(new BorderLayout(0, 0));
        f.getContentPane().add(t, BorderLayout.CENTER);
        f.pack();

        natives.Natives.RedirectOutput(t);        
        natives.Natives.ResetOutput();
    }
}

现在C++代码可以按你喜欢的方式定制。您可以在java端上创建一个方法，该方法附加到您想要的任何组件，然后让C++调用它，而不是查找文本区域并具体地附加到它。如果您这样做，那么它可以用于任何项目和任何组件，而不仅仅是文本区域

这甚至可以用于文件（

std:：fstream

）

无论如何。。结果是：

当您重定向它时：

重置时：

---

哦，上帝。。重定向到管道是我能想到的最糟糕的主意之一。。将其写入文件，然后将其读入，甚至比这更糟糕

它不符合您对“实时”或“实时”数据的要求

这些选项只能在“C”中使用，而不能在“C++”中使用。。C++有更好的方法来做你想做的事情…< /P> 您可以做的是创建自己的流，通过JNI调用直接写入您想要的任何地方。。首先需要从

std:：streambuf

继承，然后从定制类创建

std:：ostream

将

std:：cout

的rdbuf重定向到自定义流

以下是我写的：

#include "jni.h"

#include <tuple>
#include <vector>
#include <iostream>
#include <cstring>

#if defined _WIN32 || defined _WIN64
#include <windows.h>
#else
#include <sys/types.h>
#endif

#if defined _WIN32 || defined _WIN64
#define JAVA_EXPORT __declspec(dllexport)
#else
#define JAVA_EXPORT
#endif


std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>> streams;

extern "C" {
    JAVA_EXPORT void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component);
    JAVA_EXPORT void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls);
}

class redir : public std::streambuf
{
    private:
        JNIEnv* env;
        jobject comp;
        jmethodID mID;

        int_type overflow(int_type c  = traits_type::eof());

    public:
        redir(JNIEnv* e, jobject comp, jmethodID m) : env(env), comp(comp), mID(mID) {}
        ~redir() {}

        redir(const redir& other) = delete;
        redir& operator = (const redir& other) = delete;
};

redir::int_type redir::overflow(redir::int_type c)
{
    if (c != traits_type::eof())
    {
        jstring str = env->NewStringUTF((char*)&c);
        env->CallVoidMethod(comp, mID, str);
    }

    return c;
}

class rdstream : public std::ostream
{
    public:
        rdstream(JNIEnv* env, jobject comp, jmethodID mID) : std::ostream(0), sbuf(env, comp, mID) {init(&sbuf);}

    private:
        redir sbuf;
};



void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component)
{
    if (streams.empty())
    {
        jclass txtcls = env->FindClass("Ljavax/swing/JTextArea;");

        if (txtcls)
        {
            jmethodID app = env->GetMethodID(txtcls, "append", "(Ljava/lang/String;)V");

            rdstream* ctrd = new rdstream(env, component, app);
            rdstream* crrd = new rdstream(env, component, app);
            streams.push_back(std::make_tuple(ctrd, &std::cout, std::cout.rdbuf()));
            streams.push_back(std::make_tuple(crrd, &std::cerr, std::cerr.rdbuf()));
            std::cout.rdbuf(ctrd->rdbuf());
            std::cerr.rdbuf(crrd->rdbuf());

            std::cout<<"TESTING OUTPUT REDIRECTION\n";
        }
    }
}

void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls)
{
    for (std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>>::iterator it = streams.begin(); it != streams.end(); ++it)
    {
        std::get<1>(*it)->rdbuf(std::get<2>(*it));
        delete std::get<0>(*it);
    }

    streams.clear();

    std::cout<<"TESTING OUTPUT RESET\n"<<std::flush;
}

void __attribute__((constructor)) load()
{
    //Onload..
}

void __attribute__((destructor)) unload()
{
    //OnUnload..
    if (!streams.empty())
    {
        Java_natives_Natives_ResetOutput(NULL, NULL);
    }
}

和一个测试类：

package windowhandle;

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author Brandon
 */
public class WindowHandle {

    public static void main(String[] args) {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);

        JTextArea t = new JTextArea();
        t.setPreferredSize(new Dimension(500, 100));
        f.setLayout(new BorderLayout(0, 0));
        f.getContentPane().add(t, BorderLayout.CENTER);
        f.pack();

        natives.Natives.RedirectOutput(t);        
        natives.Natives.ResetOutput();
    }
}

现在C++代码可以按你喜欢的方式定制。您可以在java端上创建一个方法，该方法附加到您想要的任何组件，然后让C++调用它，而不是查找文本区域并具体地附加到它。如果您这样做，那么它可以用于任何项目和任何组件，而不仅仅是文本区域

这甚至可以用于文件（

std:：fstream

）

无论如何。。结果是：

当您重定向它时：

重置时：

---

哦，上帝。。重定向到管道是我能想到的最糟糕的主意之一。。将其写入文件，然后将其读入，甚至比这更糟糕

它不符合您对“实时”或“实时”数据的要求

这些选项只能在“C”中使用，而不能在“C++”中使用。。C++有更好的方法来做你想做的事情…< /P> 您可以做的是创建自己的流，通过JNI调用直接写入您想要的任何地方。。首先需要从

std:：streambuf

继承，然后从定制类创建

std:：ostream

将

std:：cout

的rdbuf重定向到自定义流

以下是我写的：

#include "jni.h"

#include <tuple>
#include <vector>
#include <iostream>
#include <cstring>

#if defined _WIN32 || defined _WIN64
#include <windows.h>
#else
#include <sys/types.h>
#endif

#if defined _WIN32 || defined _WIN64
#define JAVA_EXPORT __declspec(dllexport)
#else
#define JAVA_EXPORT
#endif


std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>> streams;

extern "C" {
    JAVA_EXPORT void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component);
    JAVA_EXPORT void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls);
}

class redir : public std::streambuf
{
    private:
        JNIEnv* env;
        jobject comp;
        jmethodID mID;

        int_type overflow(int_type c  = traits_type::eof());

    public:
        redir(JNIEnv* e, jobject comp, jmethodID m) : env(env), comp(comp), mID(mID) {}
        ~redir() {}

        redir(const redir& other) = delete;
        redir& operator = (const redir& other) = delete;
};

redir::int_type redir::overflow(redir::int_type c)
{
    if (c != traits_type::eof())
    {
        jstring str = env->NewStringUTF((char*)&c);
        env->CallVoidMethod(comp, mID, str);
    }

    return c;
}

class rdstream : public std::ostream
{
    public:
        rdstream(JNIEnv* env, jobject comp, jmethodID mID) : std::ostream(0), sbuf(env, comp, mID) {init(&sbuf);}

    private:
        redir sbuf;
};



void Java_natives_Natives_RedirectOutput(JNIEnv* env, jclass cls, jobject component)
{
    if (streams.empty())
    {
        jclass txtcls = env->FindClass("Ljavax/swing/JTextArea;");

        if (txtcls)
        {
            jmethodID app = env->GetMethodID(txtcls, "append", "(Ljava/lang/String;)V");

            rdstream* ctrd = new rdstream(env, component, app);
            rdstream* crrd = new rdstream(env, component, app);
            streams.push_back(std::make_tuple(ctrd, &std::cout, std::cout.rdbuf()));
            streams.push_back(std::make_tuple(crrd, &std::cerr, std::cerr.rdbuf()));
            std::cout.rdbuf(ctrd->rdbuf());
            std::cerr.rdbuf(crrd->rdbuf());

            std::cout<<"TESTING OUTPUT REDIRECTION\n";
        }
    }
}

void Java_natives_Natives_ResetOutput(JNIEnv* env, jclass cls)
{
    for (std::vector<std::tuple<std::ostream*, std::ios*, std::streambuf*>>::iterator it = streams.begin(); it != streams.end(); ++it)
    {
        std::get<1>(*it)->rdbuf(std::get<2>(*it));
        delete std::get<0>(*it);
    }

    streams.clear();

    std::cout<<"TESTING OUTPUT RESET\n"<<std::flush;
}

void __attribute__((constructor)) load()
{
    //Onload..
}

void __attribute__((destructor)) unload()
{
    //OnUnload..
    if (!streams.empty())
    {
        Java_natives_Natives_ResetOutput(NULL, NULL);
    }
}

和一个测试类：

package windowhandle;

import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author Brandon
 */
public class WindowHandle {

    public static void main(String[] args) {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);

        JTextArea t = new JTextArea();
        t.setPreferredSize(new Dimension(500, 100));
        f.setLayout(new BorderLayout(0, 0));
        f.getContentPane().add(t, BorderLayout.CENTER);
        f.pack();

        natives.Natives.RedirectOutput(t);        
        natives.Natives.ResetOutput();
    }
}

现在C++代码可以按你喜欢的方式定制。您可以在java端上创建一个方法，该方法附加到您想要的任何组件，然后让C++调用它，而不是查找文本区域并具体地附加到它。如果您这样做，那么它可以用于任何项目和任何组件，而不仅仅是文本区域

这甚至可以用于文件（

std:：fstream

）

无论如何。。结果是：

当您重定向它时：

重置时：

---

将其重定向到正在读取的管道。详细信息在一定程度上取决于您的平台。您可以按编写的方式读取文件，但最好使用命名管道。谢谢您的回答。我试着用我在这里找到的一个例子来实现您提到的（在编写文件时阅读文件）。它在Java部分中使用available（）方法读取文件，在C部分中使用sleep（）方法读取文件