小编Bla*_*way的帖子

我想定义一个模板类,其模板参数将始终是一个整数类型.该类将包含两个成员,一个是类型,另一个是类型T的无符号变体T- 即if T == int,then T_Unsigned == unsigned int.我的第一直觉是这样做:

template <typename T> class Range {
    typedef unsigned T T_Unsigned; // does not compile
public:
    Range(T min, T_Unsigned range);
private:
    T m_min;
    T_Unsigned m_range;
};

但它不起作用.然后我考虑使用部分模板专业化,如下所示:

template <typename T> struct UnsignedType {}; // deliberately empty
template <> struct UnsignedType<int> {
    typedef unsigned int Type;
};

template <typename T> class Range {
    typedef UnsignedType<T>::Type T_Unsigned;
    /* ... */
};

只要您UnsignedType对每个整数类型进行部分专门化,这都可以.这是一些额外的复制粘贴工作(削减明智地使用宏),但可以使用. …

我们在Google App Engine上有一个相当大的数据库 - 只有超过50,000个实体 - 我们希望从中清除过时的数据.计划是编写一个延迟任务来迭代我们不再需要的实体,并批量删除它们.

一个复杂因素是我们的实体也有我们想要清除的子实体 - 没问题,我们想; 我们只是查询这些实体的数据存储区,并将其与父项同时删除:

query = ParentKind.all()
query.count(100)
query.filter('bar =', 'foo')
to_delete = []
for entity in enumerate(query):
    to_delete.append(entity)
    to_delete.extend(ChildKindA.all().ancestor(entity).fetch(100))
    to_delete.extend(ChildKindB.all().ancestor(entity).fetch(100))
db.delete(to_delete)

我们限制自己一次删除100个ParentKind实体; 每个人ParentKind有大约40个孩子ChildKindA和ChildKindB实体 - 可能有4000个实体.

这在当时似乎是合理的,但是我们运行了一个批处理作为测试,结果查询运行了9秒 - 并且在可计算的CPU时间内花费了1933 秒来访问数据存储区.

这似乎相当苛刻 - 每个实体0.5个可计费秒! - 但我们并不完全确定我们做错了什么.它只是批量的大小吗？祖先的查询特别慢吗？或者,删除(实际上,所有数据存储访问)只是作为糖蜜缓慢？

更新

我们将查询更改为keys_only,虽然这样可以将运行一个批处理的时间缩短到4.5个实际秒,但CPU时间仍然需要大约1900秒.

接下来,我们将Appstats安装到我们的应用程序(感谢,kevpie)并运行一个较小的批次 - 10个父实体,总计约450个实体.这是更新的代码:

query = ParentKind.all(keys_only=True)
query.count(10)
query.filter('bar =', 'foo')
to_delete = []
for entity in enumerate(query):
    to_delete.append(entity)
    to_delete.extend(ChildKindA.all(keys_only=True).ancestor(entity).fetch(100))
    to_delete.extend(ChildKindB.all(keys_only=True).ancestor(entity).fetch(100))
db.delete(to_delete) …

基本上,我和这张海报有同样的问题,但是在C#中:等待文件可以用Win32读取

更多信息:我们的代码调用File.Open了我们的一个项目,当文件已被另一个进程(EDIT:或线程)打开时偶尔会死掉:

FileStream stream = File.Open(m_fileName, m_mode, m_access);
/* do stream-type-stuff */
stream.Close();

File.Open将抛出IOException(目前在某处悄悄吞下),其HResult属性为0x80070020(ERROR_SHARING_VIOLATION).我会喜欢做的是这样的:

FileStream stream = null;
while (stream == null) {
    try {
        stream = File.Open(m_fileName, m_mode, m_access, FileShare.Read);
    } catch (IOException e) {
        const int ERROR_SHARING_VIOLATION = int(0x80070020);
        if (e.HResult != ERROR_SHARING_VIOLATION)
            throw;
        else
            Thread.Sleep(1000);
    }
}
/* do stream-type-stuff */
stream.Close();

但是,HResult是受保护的成员Exception,并且无法访问 - 代码无法编译.有没有另一种方法可以访问HResult.NET,或者可能是另一部分我可能会用来做我想要的东西？ …

我的代码归结为以下内容:

template <typename T> struct Foo {};
template <typename T, const Foo<T>& I> struct FooBar {};

////////

template <typename T> struct Baz {};

template <typename T, const Foo<T>& I>
struct Baz< FooBar<T,I> >
{
 static void func(FooBar<T,I>& value);
};

////////

struct MyStruct
{
 static const Foo<float> s_floatFoo;
};

// Elsewhere: const Foo<float> MyStruct::s_floatFoo;

void callBaz()
{
 typedef FooBar<float, MyStruct::s_floatFoo> FloatFooBar;
 FloatFooBar myFloatFooBar;
 Baz<FloatFooBar>::func(myFloatFooBar);
}

这在GCC下成功编译,然而,在VS2005下,我得到:

error C2039: 'func' : is not a member of 'Baz<T>'
        with
        [
            T=FloatFooBar
        ]
error …

最近,我看到了这个:

struct node {
    node*  pNext;
    node** pPrevNext;
};

void insert_before(node** pNext, node* toInsert) {
    toInsert->pNext = *pNext;
    toInsert->pPrevNext = pNext;
    if (*pNext) (*pNext)->pPrevNext = &toInsert->pNext;
    *pNext = toInsert;
};

// node *a, *b;
// insert_before(a->pPrevNext, b);

它看起来像一个单链表,但包含指向前一个节点的下一个指针的指针.我的问题很简单:这叫什么？如果没有"真实姓名",搜索有关此数据结构的信息在StackOverflow和整个互联网上都会显示为空.

请注意,它不是双向链表,如下所示:

struct node {
    node* pNext;
    node* pPrev;
};

指定最大可表示负浮点数的独立于平台的方法是什么？

我们发现一个算法在 PS3 的 SPU 上运行时会出错，但在为 PPU 编译时运行良好：

float x = -FLT_MAX;
/* stuff */
if (x > 0.0f) {
    // If x is unchanged, code is executed on SPU
}

本质上，是否有一个明确定义的负等价物FLT_MAX？

在我们的系统中,我们有许多类,其构造必须异步发生.我们将构造过程包装在另一个派生类中,该类派生自一个IConstructor类:

class IConstructor {
    public:
        virtual void Update() = 0;
        virtual Status GetStatus() = 0;
        virtual int GetLastError() = 0;
};

当前系统的设计存在一个问题 - 创建IConstructor衍生类的功能通常会执行额外的工作,这些工作也会失败.此时,不是获取可以查询错误的构造函数,而是NULL返回指针.

重构代码以避免这种情况是可能的,但是很耗时.在此期间,我决定创建一个构造函数类,我们创建并在出错时返回,而不是NULL指针:

class FailedConstructor : public IConstructor
    public:
        virtual void Update() {}
        virtual Status GetStatus() { return STATUS_ERROR; }
        virtual int GetLastError() { return m_errorCode; }
    private: int m_errorCode;
};

所有这些都是一个平凡问题的设置:我怎么命名这个FailedConstructor班级？在我们当前的系统中,FailedConstructor将指示"构造一个实例的类Failed",而不是"表示构造另一个类的失败尝试的类".

我觉得它应该以其中一种设计模式命名,比如Proxy或Adapter,但我不确定是哪种.

编辑:我应该清楚地表明,我正在寻找一个坚持理想的GoF设计模式之一的答案,或者其他一些完善的命名惯例.