在Qt Creator中调试echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope代码时，出现以下错误

ptrace: Operation not permitted.

Could not attach to the process. Make sure no other debugger traces this process.
Check the settings of
/proc/sys/kernel/yama/ptrace_scope
For more details, see /etc/sysctl.d/10-ptrace.conf

在这里找到一个临时解决方案：尝试在QtProject中进行调试时收到错误

• 临时解决方案（重启后将无法生存）：

  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope

但是，每次我启动PC使用Qt时，都很难在终端中运行相同的代码。

What is the permanent solution for this?

我的结构如下：

struct app_data
{
    int port;
    int ib_port;
    unsigned size;
    int tx_depth;
    int sockfd;
    char *servername;
    struct ib_connection local_connection;
    struct ib_connection *remote_connection;
    struct ibv_device *ib_dev;

};

当我尝试这样初始化它时：

struct app_data data =
{
    .port = 18515,
    .ib_port = 1,
    .size = 65536,
    .tx_depth = 100,
    .sockfd = -1,
    .servername = NULL,
    .remote_connection = NULL,
    .ib_dev = NULL
};

我收到此错误：

sorry, unimplemented: non-trivial designated initializers not supported

我认为它要完全按照声明的顺序进行初始化，并且缺少local_connection。 我不需要初始化它，并且将其设置为NULL不起作用。

如果我将其更改为g ++，仍然会出现相同的错误：

struct app_data data =
{
    port : 18515,
    ib_port : 1,
    size : 65536,
    tx_depth : 100,
    sockfd : -1,
    servername : NULL,
    remote_connection : NULL,
    ib_dev : NULL
};

本征库可以将现有内存映射到本征矩阵。

float array[3];
Map<Vector3f>(array, 3).fill(10);
int data[4] = 1, 2, 3, 4;
Matrix2i mat2x2(data);
MatrixXi mat2x2 = Map<Matrix2i>(data);
MatrixXi mat2x2 = Map<MatrixXi>(data, 2, 2);

我的问题是，如何从特征矩阵（例如Matrix3f m）中获得c数组（例如float [] a）？ 本征矩阵的实际布局是什么？ 真实数据是否存储在普通c数组中？

有没有办法（ab）使用C预处理器在C中模拟名称空间？

我正在按照以下思路思考：

#define NAMESPACE name_of_ns
some_function() {
    some_other_function();
}

这将被转换为：

name_of_ns_some_function() {
    name_of_ns_some_other_function();
}

我从没有断言的想法-为什么您应该使用它们呢？

我的意思是，假设我是一名方程式赛车手，并且所有断言都是诸如安全带，头盔之类的东西。

测试（在调试中）都还可以，但是现在我们要进行赛车（发布）！我们应该放弃所有安全性，因为测试时没有问题吗？

我永远不会删除它们。 我认为大多数声称删除与断言可比的东西的人从未描述过他们的代码，或者断言是绝对的替代。我从未见过任何真正的性能优势，尤其是在80/20规则方面。

那么，我是否以某种方式错过了要点，或者有人可以告诉我，为什么我应该使用断言？顺便说一句，我正在使用单元测试。

我有一个char *和从库中接收到的数据长度，我需要将数据传递给采用istream的函数。

我知道我可以创建一个字符串流，但是它将复制所有数据。 而且，由于它是一个zip文件，因此数据肯定会为0，而创建stringstream会将数据一直存储到我认为的第一个0。

有什么方法可以从char *创建一个istream，它的大小无需复制所有数据吗？

该代码有什么问题？

#include <map>

template<typename T>
struct TMap
{
    typedef std::map<T, T> Type;
};

template<typename T>
T test(typename TMap <T>::Type &tmap_) { return 0.0; }

int _tmain(int argc, _TCHAR* argv[])
{
    TMap<double>::Type tmap;
    tmap[1.1] = 5.2;
    double d = test(tmap); //Error: could not deduce template argument for T
    return 0;
}

如果我有类似的东西

class Base {
    static int staticVar;
}

class DerivedA : public Base {}
class DerivedB : public Base {}

DerivedA和DerivedB是否会共享相同的staticVar，或者它们各自拥有自己的？

如果我希望他们每个人都有自己的，您会建议我做什么？

您对创建单个实例应用程序有什么建议，以便一次只允许一个进程运行？ 文件锁，互斥锁还是什么？

我正在尝试通过system()（例如system("ls")）启动外部应用程序。我想捕获其发生的输出，以便将其发送到另一个函数进行进一步处理。 在C / C ++中执行此操作的最佳方法是什么？

将浮点常量声明为static constexpr变量与下面的示例中的函数之间是否有区别，还是仅是样式问题？

class MY_PI
{
public:
    static constexpr float MY_PI_VAR = 3.14f;
    static constexpr float MY_PI_FUN() { return 3.14f; }
}

只是一个帖子，以帮助那些尝试这样做的人，因为我没有博客。

这也适用于linux。 随时对其进行编辑和改进。

我目前正在学习C ++（来自Java），并且试图了解如何在C ++中正确使用IO流。

假设我有一个istream类，其中包含图像的像素，并且我重载了提取运算符以从流中读取图像：

istream& operator>>(istream& stream, Image& image)
{
    // Read the image data from the stream into the image
    return stream;
}

因此，现在我可以读取如下图像：

Image image;
ifstream file("somepic.img");
file >> image;

但是现在我想使用相同的提取运算符从自定义流中读取图像数据。 假设我有一个文件，其中包含压缩格式的图像。 因此，我可能不希望使用ifstream来实现自己的输入流。 至少这就是我在Java中的做法。 在Java中，我将编写一个自定义类，以扩展istream类并实现streambuf方法。 这很容易。 用法如下所示：

InputStream stream = new CompressedInputStream(new FileInputStream("somepic.imgz"));
image.read(stream);

因此，使用相同的模式也许我想在C ++中做到这一点：

Image image;
ifstream file("somepic.imgz");
compressed_stream stream(file);
stream >> image;

但这也许是错误的方式，不知道。 扩展istream类看起来非常复杂，经过一些搜索，我发现了一些有关扩展streambuf的提示。 但是对于如此简单的任务，此示例看起来非常复杂。

那么在C ++中实现自定义输入/输出流（或streambufs？）的最佳方法是什么？

解

有人建议完全不要使用iostream，而应使用迭代器，boost或自定义IO接口。 这些可能是有效的替代方法，但我的问题是关于iostream的。 接受的答案产生了以下示例代码。 为了更容易阅读，没有标题/代码分离，并且导入了整个std名称空间（我知道这在实际代码中是一件坏事）。

这个例子是关于读写垂直异或编码的图像的。 格式很简单。 每个字节代表两个像素（每个像素4位）。 每行与上一行进行异或。 这种编码为压缩准备了图像（通常会导致很多0字节，这更容易压缩）。

#include <cstring>
#include <fstream>

using namespace std;

/*** vxor_streambuf class ******************************************/

class vxor_streambuf: public streambuf
{
public:
    vxor_streambuf(streambuf *buffer, const int width) :
        buffer(buffer),
        size(width / 2)
    {
        previous_line = new char[size];
        memset(previous_line, 0, size);
        current_line = new char[size];
        setg(0, 0, 0);
        setp(current_line, current_line + size);
    }

    virtual ~vxor_streambuf()
    {
        sync();
        delete[] previous_line;
        delete[] current_line;
    }

    virtual streambuf::int_type underflow()
    {
        // Read line from original buffer
        streamsize read = buffer->sgetn(current_line, size);
        if (!read) return traits_type::eof();

        // Do vertical XOR decoding
        for (int i = 0; i < size; i += 1)
        {
            current_line[i] ^= previous_line[i];
            previous_line[i] = current_line[i];
        }

        setg(current_line, current_line, current_line + read);
        return traits_type::to_int_type(*gptr());
    }

    virtual streambuf::int_type overflow(streambuf::int_type value)
    {
        int write = pptr() - pbase();
        if (write)
        {
            // Do vertical XOR encoding
            for (int i = 0; i < size; i += 1)
            {
                char tmp = current_line[i];
                current_line[i] ^= previous_line[i];
                previous_line[i] = tmp;
            }

            // Write line to original buffer
            streamsize written = buffer->sputn(current_line, write);
            if (written != write) return traits_type::eof();
        }

        setp(current_line, current_line + size);
        if (!traits_type::eq_int_type(value, traits_type::eof())) sputc(value);
        return traits_type::not_eof(value);
    };

    virtual int sync()
    {
        streambuf::int_type result = this->overflow(traits_type::eof());
        buffer->pubsync();
        return traits_type::eq_int_type(result, traits_type::eof()) ? -1 : 0;
    }

private:
    streambuf *buffer;
    int size;
    char *previous_line;
    char *current_line;
};


/*** vxor_istream class ********************************************/

class vxor_istream: public istream
{
public:
    vxor_istream(istream &stream, const int width) :
        istream(new vxor_streambuf(stream.rdbuf(), width)) {}

    virtual ~vxor_istream()
    {
        delete rdbuf();
    }
};


/*** vxor_ostream class ********************************************/

class vxor_ostream: public ostream
{
public:
    vxor_ostream(ostream &stream, const int width) :
        ostream(new vxor_streambuf(stream.rdbuf(), width)) {}

    virtual ~vxor_ostream()
    {
        delete rdbuf();
    }
};


/*** Test main method **********************************************/

int main()
{
    // Read data
    ifstream infile("test.img");
    vxor_istream in(infile, 288);
    char data[144 * 128];
    in.read(data, 144 * 128);
    infile.close();

    // Write data
    ofstream outfile("test2.img");
    vxor_ostream out(outfile, 288);
    out.write(data, 144 * 128);
    out.flush();
    outfile.close();

    return 0;
}

我想将几个类的实例存储在向量中。 由于所有类都继承自相同的基类，因此这应该是可能的。

想象一下这个程序：

#include <iostream>
#include <vector>
using namespace std;

class Base
{
    public:
    virtual void identify ()
    {
        cout << "BASE" << endl;
    }
};

class Derived: public Base
{
    public:
    virtual void identify ()
    {
        cout << "DERIVED" << endl;
    }
};

int main ()
{
    Derived derived;

    vector<Base> vect;
    vect.push_back(derived);

    vect[0].identify();
    return 0;
}

我希望它可以打印“ DERIVED”，因为“ identify”方法是虚拟的。 相反，“ vect [0]”似乎是“基本”实例，它会打印

基础

我想我可以以某种方式编写自己的容器（可能是从向量派生的）（可以只保存指针...）。 我只是想问一下是否还有更多的C ++ ish方法来执行此操作。 并且我希望完全与向量兼容（仅为方便起见，如果其他用户应该使用我的代码）。

我有一个C ++程序。 该程序执行以下操作：

struct MyT {void memfunc(std::unique_ptr<MyT> arg);};
std::unique_ptr<MyT> obj = /* some init */;
obj->memfunc(std::move(obj));

这样是否可以保证有效，或者我最终可以在nullptr上调用成员函数？
适用标准报价。
我知道参数的评估顺序是无顺序的，但是我不记得顺序是什么。 被调用的功能对象。

我在我们的代码中看到了一个函数声明，如下所示

void error(char const *msg, bool showKind = true, bool exit);

我首先认为这是一个错误，因为您不能在函数中间使用默认参数，但是编译器接受了此声明。 有没有人见过这个？ 我正在使用GCC4.5。 这是GCC扩展程序吗？

奇怪的是，如果我将其取出来放在单独的文件中并尝试进行编译，则GCC会拒绝它。 我已经仔细检查了所有内容，包括使用的编译器选项。

我一直在使用std::memcpy来规避严格的别名。

例如，检查std::memcpy，如下所示：

float f = ...;
uint32_t i;
static_assert(sizeof(f)==sizeof(i));
std::memcpy(&i, &f, sizeof(i));
// use i to extract f's sign, exponent & significand

但是，这一次，我检查了标准，但没有发现任何可以验证此标准的东西。 我发现的是：

对于平凡可复制的类型T的任何对象（可能重叠的子对象除外），无论该对象是否持有类型T的有效值，都可以将构成对象的基础字节（[intro.memory]）复制到一个对象中。 char，unsigned char或std :: byte（[cstddef.syn]）数组。[40]如果将该数组的内容复制回该对象，则该对象随后应保持其原始值。 [示例：

std::memcpy

—示例]

还有这个：

对于任何普通可复制类型T，如果将组成obj1的基础字节（[intro.memory]）复制到其中，则指向T的两个指针指向不同的T对象obj1和obj2，其中obj1和obj2都不是潜在重叠的子对象。 obj2,41 obj2随后应保持与obj1相同的值。 [示例：

std::memcpy

—示例]

因此，允许std::memcpy将std::memcpy与unsigned char[]进行往返，也允许shift在相同的普通类型之间进行。

我的第一个示例（以及链接的答案）是否定义明确？ 还是检查std::memcpy的正确方法是将std::memcpy放入unsigned char[]缓冲区，然后使用shift和ors从中构建uint32_t？

注意：查看std::memcpy的担保可能无法回答此问题。 据我所知，我可以用一个简单的字节复制循环替换std::memcpy，问题将是相同的。

我试图了解如何使用参考参数。 我的文字中有几个示例，但是对于我来说，它们太复杂了，无法理解为什么以及如何使用它们。

您想如何以及为什么要使用参考？ 如果您不将参数设为引用，而是将&设为关闭，会发生什么情况？

例如，这些功能之间有什么区别：

int doSomething(int& a, int& b);
int doSomething(int a, int b);

我知道使用引用变量来更改形式引用，然后允许双向交换参数。 但是，这是我所了解的程度，一个更具体的示例会很有帮助。

C ++ 20中有一个新的比较运算符<=>。 但是，我认为在大多数情况下，简单的减法效果很好：

int my_strcmp(const char *a, const char *b) {
    while (*a == *b && *a != 0 && *b != 0) {
        a++, b++;
    }
    // Version 1
    return *a - *b;
    // Version 2
    return *a <=> *b;
    // Version 3
    return ((*a > *b) - (*a < *b));
}

它们具有相同的效果。 我真的不明白区别。

有人可以指导我如何使用C ++进行函数式编程吗？ 我可以参考一些好的在线资料吗？

请注意，我了解FC ++库。 我想知道如何仅使用C ++标准库来做到这一点。

谢谢。