小编Fir*_*cer的帖子

无论如何都要读取已知的字节数,直接读入std :: string,而不创建临时缓冲区吗？

例如,目前我可以做到

boost::uint16_t len;
is.read((char*)&len, 2);
char *tmpStr = new char[len];
is.read(tmpStr, len);
std::string str(tmpStr, len);
delete[] tmpStr;

我想存储一堆键值对象,但值对象本身(及其对它的引用)知道它的键.我还想在只给出密钥的情况下有效地查找这些对象.

class SomeObject
{
private:
    //String or integer. int seem cheap enough to duplicate with std::map, but
    //strings seem pretty expensive when there may be thousands of objects in existence.
    //Reference/Pointer to key is fine
    const SomeOtherObject key;
    ...other stuff...
public:
    ...methods, some of which use the key in some way...
};

• 的std ::地图
  • 似乎要求存储是std :: pair,这样值就无法访问密钥.如果值包含密钥,则需要重复该密钥.
  • 实际上并不强制执行值内部的键不会以某种方式更改
• 的std ::设为
  • 看起来是一个非常好的解决方案,使用自定义比较方法按键提供唯一性,直到您意识到它使您的整个值成为常量,而不仅仅是关键字段.
• std :: vector(或其他数组/列表之类的解决方案)
  • 可以使用线性搜索,或者如果项目保持排序二进制搜索.但是我怀疑这在性能方面并不是最优的,并且需要额外的某种层才能真正实现所需的行为.

我有一个div可能会在添加或删除内容时溢出.

然而,UI设计者不希望看到但不活动的滚动条(与之一样overflow: scroll),并且他们不希望在添加和删除内容布局时更改内容布局(如同overflow: auto).

是否有办法获得此行为,并考虑不同平台和浏览器上的不同滚动条.

https://jsfiddle.net/qy9a2r00/1/

说我有:

void Render(void(*Call)())
{
    D3dDevice->BeginScene();
    Call();
    D3dDevice->EndScene();
    D3dDevice->Present(0,0,0,0);
}

只要我想用于渲染的函数是函数或static成员函数,这就没问题了:

Render(MainMenuRender);
Render(MainMenu::Render);

但是,我真的希望能够使用类方法,因为在大多数情况下,渲染函数将要访问成员变量,而Id则不会使类实例成为全局,例如

Render(MainMenu->Render);

但是我真的不知道如何做到这一点,仍然允许使用函数和static成员函数.

如何在我的python脚本中检测它是否由调试解释器运行(即python_d.exe而不是python.exe)？我需要改变传递给扩展的一些dll的路径.

例如,我喜欢在我的python脚本开头做类似的事情:

#get paths to graphics dlls
if debug_build:
    d3d9Path   = "bin\\debug\\direct3d9.dll"
    d3d10Path  = "bin\\debug\\direct3d10.dll"
    openGLPath = "bin\\debug\\openGL2.dll"
else:
    d3d9Path   = "bin\\direct3d9.dll"
    d3d10Path  = "bin\\direct3d10.dll"
    openGLPath = "bin\\openGL2.dll"

我想在扩展中添加一个"IsDebug()"方法,如果它是调试版本(即使用"#define DEBUG"构建),则返回true,否则返回false.但这似乎是一个黑客的东西我确定我可以让python告诉我...

我希望能够保存和加载RNG的状态,这样我就可以从给定的点(应用程序保存/快照)重现相同的随机值.

我看到有一个运算符<<和>>重载,它似乎将字符串保存为一系列数字.

• 这是保存的最佳/唯一方式吗？我不介意只有固定大小的二进制状态值而不是这个空格分隔的字符串,然后我需要为我的文件格式添加前缀或分隔符.
• 这一切都是便携式的吗？例如,我可以在不同的编译器版本之间,甚至在MSVC和GCC之间传输它,以在给定相同配置的分布的情况下生成相同的数据集(在浮点的情况下为小的误差范围,对于整数数学是精确的)？

说我有一个像这样的简单类

class Foo
{
public:
    void foo()const
    {
        str[5] = 'x';
        obj->changeTheWorld();
        x = 4;
        y.get() = 5;
        obj2->changeTheWorld();
    }
private:
    char *str; //some referenced data, not owned by Foo
    ComplexObj *obj; //some referenced data, not owned by Foo
    int &x; //references as well
    //wrapped reference, but has a "T& get()const"
    std::reference_wrapper<int> y;
    //an occasionally useful pointer wrapper for complex memory cases
    //but has a "T* get()const"
    std::shared_ptr<ComplexObj> obj2;
};

这是有效的,因为在const方法中,它只是指针本身变为const,而不是它指向的数据.但是在许多情况下,这不是我想要的,如果const方法试图改变这些成员内容(直接或通过在该成员上调用非const方法),我想要编译错误.

有没有标准的解决方案？

我认为某种包装类应该能够实现这一点,并且也应该是编译器优化的东西,尽管还没有坐下来尝试设计这样的东西来覆盖所有的情况下给出一个strong_const<char*> str和strong_const<int&>(也不确定)一个好名字......).

我遇到了一个问题,如果我有一个模板类,它反过来有一个模板方法,它接受该类的另一个实例的参数(具有不同的模板参数),它不能访问传递给该类的受保护或私有成员参数,例如:

template<typename T>class MyClass
{
    T v;
public:
    MyClass(T v):v(v){}

    template<typename T2>void foo(MyClass<T2> obj)
    {
        std::cout << v     << " ";
        //error C2248: 'MyClass<T>::v' : cannot access private member declared in class 'MyClass<T>'
        std::cout << obj.v << " ";
        std::cout << v + obj.v << std::endl;
    }
};
int main()
{
    MyClass<int> x(5);
    MyClass<double> y(12.3);
    x.foo(y);
}

是否有人说MyClass <T>中的方法可以完全访问MyClass <SomeOtherT>？

我经常看到代码添加一个值,例如指针的长度,然后使用这个值,例如

T* end = buffer + bufferLen;//T* + size_t

if (p < end)

但是,缓冲区是否有可能在"buffer + bufferLen"可能溢出的内存末尾附近分配(例如0xFFFFFFF0 + 0x10),导致"p <end"为假,即使p是有效的元素地址(例如0xFFFFFFF8).

如果有可能的话,当我看到许多与开始/结束范围一起工作的东西时,如何避免在最后一个元素之后结束下一个元素

我有一个小类(32位系统上16个字节),我需要动态分配.在大多数情况下,任何给定实例的生命周期都非常短.某些实例也可以跨线程边界传递.

做了一些分析后,我发现我的程序似乎花费了更多的时间来分配和解除分配,而不是实际花费使用它们所以我想用更高效的东西替换默认的new和delete.

对于一个大型对象(db连接,因为它发生,构造而不是分配是昂贵的),我已经在使用池系统,但是它涉及一个用于存储"free"对象的列表,还有一个用于线程安全的互斥锁.在互斥锁和列表之间,它实际上比小对象的基本新建/删除更糟糕.

我在Google上发现了许多小对象分配器,但它们似乎使用的是全局/静态池,它不是以线程安全的方式使用,使它们不适合我的用途:(

我有哪些其他选项可以有效地管理这些小对象？