小编Ann*_*inn的帖子

使用cstdio，覆盖文件的最安全方法是什么？在这种情况下，“安全”意味着文件不可能不完整或损坏；该文件将被完全覆盖，或者如果出现问题，它将是旧文件。

我想最好的方法是创建一个临时中间文件，然后在该中间文件完成后覆盖旧文件。如果这实际上是最好的方法，那么还有一些其他问题似乎是可能的，尽管很少见。

• 如果程序在覆盖时退出，我怎么知道要使用这个其他文件？
• 如果程序在创建过程中退出，我怎么知道不使用其他文件？
• 我怎么知道原始文件或中间文件处于未定义状态（因为它可能以一种保持可读的方式失败，但它包含的数据有细微的错误）？

我想这有一个很好的做法，但我找不到它。这是用于保存的游戏数据；只有一个文件，而且每次都会覆盖整个文件，无需担心部分覆盖或附加。

我怎样才能得到 aweak_ptr<void>到 a shared_ptr<Type>？

我如何锁定 aweak_ptr<void>并最终生成 a shared_ptr<Type>？

Type有一个不平凡的析构函数，假设weak_ptr<...>永远不会调用这个析构函数是否正确？

void 弱指针是我在这种情况下想要的，它仅用于监视多种类型的共享指针的引用计数，并给出指向现有对象的共享指针，而本身不拥有该对象（它是一个对象的一部分）参考资源管理器）。

我读过，VBO（顶点缓冲区对象）本质上保留了一个引用计数，因此，如果将 VBO 的名称指定给 ，那么glDeleteBuffers()如果活动的 VAO（顶点数组对象）仍然引用它，它就不会真正被忽略。这种行为类似于越来越多的新语言采用的“智能指针”。但在多大程度上这是正确的并且可以围绕它进行设计，以及它是否也适用于 IBO（索引缓冲区对象），我还没有找到任何相关信息。

如果一个 VBO 被引用它的 VAO 保持存活，并且我不打算在 VAO 死亡后更新它或使用它，我认为最好的做法是销毁我对它的引用。这样做合适吗？我可以对 IBO 做同样的事情吗？

假设我有一个大的,在50到200之间的单个函数池,它的作用是对单个对象进行操作并对其进行修改.功能池被选择性地放入单个阵列中并以任意顺序排列.

函数本身不在其正在修改的对象中存在的值之外的参数,并且以这种方式,对象的行为仅由执行哪些函数以及以什么顺序确定.

到目前为止我暂时使用的一种方法是,这可以更好地解释我的目标是什么:

class Behavior{
    public:
    virtual void act(Object * obj) = 0;
};

class SpecificBehavior : public Behavior{
    // many classes like this exist
    public:
    void act(Object * obj){ /* do something specific with obj*/ };
};

class Object{
    public:
    std::list<Behavior*> behavior;

    void behave(){
        std::list<Behavior*>::iterator iter = behavior.front();
        while(iter != behavior.end()){
             iter->act(this);
             ++iter;
        };
    };
};

我的问题是,在性能和可维护性方面,C++在组织这样一个功能池方面最有效的方法是什么.这是我正在进行的一些人工智能研究,这种方法与我想要达到的最接近.

编辑:阵列本身可以随时由此处未列出的代码的任何其他部分进行更改,但保证在调用期间永远不会更改behave().它存储的数组需要能够更改并扩展到任何大小

在C++中,它是标准的始终使用new过malloc().但是,在这个问题中,new在避免平台特定代码的同时使运营商超载的最便携方式是malloc()在其中进行调用以进行实际分配.

当重载时,调用构造函数并保持类型安全性.此外,您还可以监视和控制内存的分配方式.

我的问题是,在这个容量中使用时,malloc()在C++中使用仍然有任何缺点吗？

我的问题是,在C++中,是否定义了以下代码？一些吗？如果是的话,它应该在这四种场景中做些什么呢？

word <<  100;
word >>  100;
word << -100;
word >> -100;

这个词是 uint32_t

(这是3D照明渲染器的一个瓶颈.我想做的最内层循环中的一个较小的改进是消除不必要的条件分叉.其中一个分叉是检查是否应该在几个32上完成左移.位字作为汉明重量计数的一部分.如果左移接受荒谬值,则根本不需要进行检查)

Is there a way to determine the position of an iterator inside it's container? The "position" I'm looking would take the form of an integer value, that describes how far from the beginning of the container the iterator is.

For example,vector.front() would be 0, and vector.back() would be vector.size() - 1

有没有一种方法可以在编译时为字符串或加密的字符串创建哈希值？我想将生成加密文本或哈希值的原始字符串直接作为字符串文字放入我的代码中，但是我不希望它们以未转换的形式被编译成可执行文件。

像这样吗

constexpr uint32 hash(const char * string){
    ... // turns a string into a value to represent it
}
constexpr std::string encrypt(const char * string){
    ... // turns a string into a cyphertext (unsure what return type would work best here)
}

void f(){

    std::string input << std::cin();

    switch(hashedKey){
        case hash("help"): // legal?
            if(0 == encryptRT(input).compare(encrypt("secret string")){
                // the secret string should never appear in the executable
            }
            break;
    }
}

非常重要的一点是，直接放入constexpr函数中的字符串切勿放入字符串表中。这可能吗？

如何定义一个类型uintptr，使其至少可以容纳a uint32_t和a uintptr_t，而不必求助于并集？

sizeof()在预处理器中被允许，这将完成我想要的操作：

#include <inttypes.h>
#if sizeof(uint32_t) > sizeof(uintptr_t)  // unlikely, but the standard allows it
    typedef uint32_t uintptr;  
#else
    typedef uintptr_t uintptr;
#endif

uint32_t如果不等于，极有可能会变小，uintptr_t但标准不能保证。话虽如此，这样的平台将非常罕见，所以到目前为止，我已经通过解决以下问题解决了这个问题：

static_assert(sizeof(uint32_t) <= sizeof(uintptr_t), "Yikes");
typedef uintptr_t uintptr;

我一直认为 lambda 只是函数指针，但我从未想过认真使用 capture 语句......

如果我创建一个通过副本捕获的 lambda，然后将该 lambda 移动到完全不同的线程，并且不尝试保存 lambda 中使用的原始对象，它会为我保留这些副本吗？

std::thread createThread() {
    std::string str("Success");
    auto func = [=](){ 
        printf("%s", str.c_str());
    };
    str = "Failure";
    return std::thread(func);
}

int main() {
    std::thread thread = createThread();
    thread.join();  
    // assuming the thread doesn't execute anything until here...
    // would it print "Success", "Failure", or deference a dangling pointer?
    return 0;
}