小编keb*_*ebs的帖子

我正在使用GLFW,所以用OpenGL设置一个Window.由于我刚刚开始学习OpenGL及其周围的所有内容,这可能听起来像一个愚蠢的问题,但为什么GLFW的示例程序在Window未被主动显示时使用接近100%的CPU(最小化或被另一个窗口隐藏) )？

这是GLFW的例子,我在Mac OS上使用Xcode运行它:

#include <GLFW/glfw3.h>
int main(void)
{
    GLFWwindow* window;

    if (!glfwInit())  /* Initialize the library */
        return -1;

/* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
       glfwTerminate();
        return -1;
    }

/* Make the window's context current */
    glfwMakeContextCurrent(window);

/* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */

        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll …

我从昨天开始就被这个问题困住了。不幸/幸运的是，这个问题只占我超级庞大（对我来说，一个 c++ 新手）算法的 0.5% 左右，因此需要一个现有代码库，一个可以适应并让事情正常工作的现有代码库。

我想检测并给出无向图中的所有圆圈。我的边缘没有加权。是的，我真正需要的是所有循环，即类似于有向图的所有哈密顿循环

我一直在玩boost图库，DFS算法似乎很有前途，但是，它只访问顶点一次，因此不能给出所有的哈密顿圆。

目前，我只需要代码工作，这样我就可以继续我的算法设计，之后我可能会考虑性能问题。即使是带有 5 个嵌套 for 循环的解决方案也是受欢迎的。

这是我从 boost 得到并玩过的代码，但我不知道如何记录和访问我的 back_edges 的前辈，即使解决了，boost DFS 也只会访问顶点一次：

struct detect_loops : public boost::dfs_visitor<>
{
   template <class Edge, class Graph>
   void back_edge(Edge e, const Graph& g) {
      std::cout << source(e, g)
        << " -- "
        << target(e, g) << "\n";
   }
};

int main(int,char*[])
{
    typedef std::pair<int,int> Edge;
    std::vector<Edge> edges;
    edges.push_back(Edge(0,1));
    edges.push_back(Edge(1,2));
    edges.push_back(Edge(2,3));
    edges.push_back(Edge(3,1));
    edges.push_back(Edge(4,5));
    edges.push_back(Edge(5,0));
    edges.push_back(Edge(4,0));
    edges.push_back(Edge(5,6));
    edges.push_back(Edge(2,6));

    typedef adjacency_list<
       vecS, vecS, undirectedS, no_property,
       property<edge_color_t, default_color_type>
    > graph_t;
    typedef …

我在使用 gnuplot 时遇到了一些问题。这是我的数据文件：

From Time Packets Jitter  
127.0.0.1:53091 1 0 274  
127.0.0.1:53091 2 0 417  
127.0.0.1:53091 3 36 53  
127.0.0.1:53091 4 215 55  
127.0.0.1:53090 4 215 55  
127.0.0.1:53091 5 215 33  
127.0.0.1:53090 6 256 78

（我把那个“时间”用于测试，但它会在它工作后被日期时间替换）

我想绘制两个不同的图形，Time在 x 轴上都有列，在 y 轴上有Packets列（在第一个图形上）和抖动列（在第二个图形上）。但是，正如您可能已经看到的，我不知道From列中有多少个不同的值（最小 1，但我不知道最大值，数据文件将被刷新，并且每个 x 将添加一些值秒）。
所以我的问题是我想From在两个图形上制作另一条“线”，每个不同的值。
实际上，在行From标题中具有值（例如：“127.0.0.1:53091”）。
如果可以更改列顺序，我想补充一点。

我试过：

plot 'data.log' using 3:xtic(2) title 'Packets' with lines, \
     'data.log' using 4:xtic(2) title 'Jitter' with lines

但它在同一个图形上（我还没有使用 multiplot，我之前尝试使多条线起作用）。

是否可以 ？如果是，我如何在 gnuplot 中绘制这两个图形？ …

在返回"默认格式"的意义上,我遇到浮点值的格式问题.说我有2个花车:

float f1 = 3.0f, f2 = 1.5f;
std::cout << f1 << " - " << f2 << "\n";

将这些显示为: 3 - 1.5

现在,出于某种原因,我需要设置精度std::cout(用于其他打印):

cout << std::precision(2);

如果我再次打印我的两个花车,这将导致: 3.00 - 1.50

现在我想恢复默认格式.直到C++ 11,这似乎很难(或者是它？).但是,谢谢,我现在得到了这个新标志: std :: defaultfloat.我们试试吧:

std::cout << std::defaultfloat << f1 << " - " << f2;

将打印:3 - 1.50.精细.

哦,等等.说我有:

float f1 = 444.0f, f2 = 444.5f;

默认打印将显示: 444 - 444.5

设定精度(和"固定"):

cout << std::precision(2) << std::fixed;

将会呈现: 444.00 - 444.50

但回到"默认":

std::cout …

考虑以下代码，该代码尝试从派生类运算符调用基类比较运算符：

struct Base
{
    protected:
    int _a;
    bool operator == ( const Base& other ) const
    {
        return (_a == other._a);
    }
};

struct Derived : public Base
{
    bool operator == ( const Derived& other ) const
    {
        return static_cast<Base>(*this) == static_cast<Base>(other);
    }
};

int main()
{
    Derived b1, b2;
    if( b1 == b2 )
        ;
}

失败的原因是：

main.cpp：25：61：错误：'bool Base :: operator ==（const Base＆）'在此上下文中受保护返回static_cast（* this）== static_cast（other）;

我不明白为什么我不能从派生类访问此运算符。

我在询问之前做了一些搜索，发现了另一个看起来相似的问题。然而：

1. 在另一个问题中，当我需要比较相同类型的对象时，OP希望将其（派生类）与基类对象进行比较。
2. 我不明白给出的解释。
3. 情况有些不同：在另一个问题中，被接受的答案建议对派生类中的基本成员进行比较。如果必须在基类中进行比较该怎么办？

关于第2点，让我详细说明：@Barry 接受的答案 …

我有一个小的C++库,在Linux上编译很好(这是我的主要开发平台).现在我正在尝试使用Mingw在Windows机器(XP3)上构建它,并且由于无法解释的错误,编译失败.例如,假设在类AAA中,在命名空间aaa中有以下方法,在文件aaa.h中声明:

void AAA::DrawText( foo z );

在编译文件aaa.cpp(当然包含方法实现)时,我收到以下错误:

D:\dev\[...]\aaa.cpp:644: error: no 'void aaa::AAA::DrawTextA( foo z )' member function declared in class 'aaa::AAA'

是的,你得到了它,没有错误 ...编译器误读了函数名称,并在函数标识符中添加了一个字母!

这完全不在我的理解之下.在Linux上从未遇到过这样的问题.mingw/Gcc如何更改标识符？

名字错了吗？不,这在编译后发生.

我当然检查了确切的命令行(我使用IDE):没有错:

mingw32-g++.exe -W  -O3 -Wall    -I..\include -I"C:\program files\OpenCV2.1\include\opencv"  -c D:\dev\...\aaa.cpp -o ..\obj\Release\src\aaa.o

但是:如果我将函数重命名为DrawTxt(),那么一切都很顺利(但我不能这样做).这对我来说意味着标识符已在某处定义.Opencv lib？掠过树,什么也没找到......是的,我搜索了当前的包含文件夹,没有任何关闭.

我看到的另一个解决方案是某处(？)宏像:

#define DrawText DrawTextA

在某些情况下被激活.

所以我的问题是:

• 在我的代码中是否还有其他可能的名称替换？对我来说,宏是唯一的方法,如果标识符已在其他地方声明,它只会抛出一个错误,编译器不能(好吧......)匆匆地改变/替换/编辑标识符.
• 我该如何追踪问题？

假设我在某个地方有一个独特的文件file.ext.它由我的Ubuntu框索引,所以命令locate file.ext正确地给了我(单个)位置,比方说/usr/local/some/place/file.ext.

所以我认为这个:

locate file.ext | xdg-open

将使用与文件类型相关联的默认应用程序打开文件(有一个,这不是问题),就像我已输入 xdg-open /usr/local/some/place/file.ext

相反,我得到了"使用"消息xdg-open,好像它是在没有参数的情况下调用的.

所以问题是:我对管道有什么不妥吗？或者这个特定命令有些问题？

Fortify在下面的代码中报告了一个缓冲区溢出漏洞,理由如下:

在这种情况下,我们主要关注案例"取决于在代码的直接范围之外强制执行的数据的属性".,因为我们无法验证abc.cpp中memcpy()执行的操作的安全性

void create_dir(const char *sys_tmp_dir,  const char *base_name,
                size_t     base_name_len)
{
    char        *tmp_dir;
    size_t      sys_tmp_dir_len;

    sys_tmp_dir_len = strlen(sys_tmp_dir);

   tmp_dir = (char*) malloc(sys_tmp_dir_len + 1 + base_name_len + 1);
   if(NULL == tmp_dir) 
     return;

memcpy(tmp_dir, sys_tmp_dir, sys_tmp_dir_len);
tmp_dir[sys_tmp_dir_len] = FN_LIBCHAR;
memcpy(tmp_dir + sys_tmp_dir_len + 1, base_name, base_name_len);
tmp_dir[sys_tmp_dir_len + base_name_len + 1] = '\0';
..........
..........

}

在我看来这是一个误报,因为我们首先得到数据的大小,分配大量的空间,然后调用memcpy大小来复制.但我正在寻找有充分理由说服其他开发人员摆脱当前的实现,而不是使用c ++字符串.这个问题已经分配给他了.他只是认为这是一个误报,所以不想改变任何东西.

编辑我看到对当前代码的快速,有效的批评.希望我现在能够说服他.否则,我会拿着接力棒.:)

这是一个简单的线程跟踪程序.线程只打印前十个整数,然后打印"线程完成"消息.

#include <iostream>
#include <vector>
#include <numeric>
#include <thread>

void f();

int main(int argc, const char * argv[]) {
    std::thread t(f);

    std::cout << "Thread start" << std::endl;

    t.detach();
    t.join();

    std::cout << "Thread end" << std::endl;

    return 0;
}

void f()
{
    std::vector<int> a(10);
    std::iota(a.begin(), a.end(), 0);

    for(const int& i : a)
    {
        std::cout << i << std:: endl;
    }
    std::cout << "Thread is done." << std::endl;
}

但是,当它运行时,t.join会在libc ABI中的某处抛出一个std :: __ 1 :: system_error异常,导致程序以SIGABRT终止:

Thread start
0
1
2
3 …

我需要一个模板化的稀疏矩阵实现,但只是为了减少内存占用,而不是做任何数值求解.所以我尝试使用Eigen,即使我不需要数学部分.为什么？它碰巧躺在我的机器上,我已经用它来做其他东西了.但我肯定不是本征专家!

背景:我有一个类型T(比如struct T{int a; float b; vector<int> c; };,我需要存储的大型矩阵这个(比如超过1000×1000)和大部分值为null /无关.

由于我没有做任何数学运算,我认为提供存储/检索操作就足以提供存储/检索操作,如下所示:

int main()
{
    Eigen::SparseMatrix<MyClass> mat(1000,1000); // 1000000 elements
    MyClass b{ 5, 1.2 };
    mat.insert( 3, 4 ) = b;
}

所以这是一个数据类型,我认为是必要的:

struct MyClass
{
    int a;
    float b;
    std::vector<int> v_things;

    MyClass( int aa, float bb ) : a(aa), b(bb) {}
    MyClass( const MyClass& other ) // copy constructor
    {
        a = other.a;
        b = other.b;
        v_things = other.v_things;
    }
    MyClass& operator=( const …