小编por*_*uod的帖子

使用pysqlite我正在制作一个程序来处理某些数据.同样种类的操作是在多个表和列类似领域完成的,所以我想我可以参数化的SQL语句,如下所示:

def foo():
  column = 'c'
  table = 't'
  row = 1
  # preferred approach, gives syntax error
  c.execute('SELECT ? FROM ? WHERE id=?', (column, table, row))
  # sanity check, works fine
  c.execute('SELECT c FROM t WHERE id=?', (row))
  # workaround, also works, but is this the right way?
  c.execute('SELECT % FROM % WHERE id=?' % (column, table), row))

我得到的错误是不是非常有帮助(sqlite3.OperationalError: near "?": syntax error),但我得到了这一点:在以这种方式使用的占位符Pysqlite并不领情.

谁能指出这里发生了什么以及正确的做法？

我正在寻找像stl(push_heap,, )中的算法pop_heap,make_heap除了能够有效地弹出最小值和最大值.AKA双端优先级队列.如上所述这里.

作为替代方案,双端优先级队列的任何干净实现也是有意义的,但是这个问题主要是关于MinMax Heap实现.

我的google-fu并不富有成效,但当然,它必须存在？

我已经达到了一个项目的重点,开始为向量和misc三角函数构建一些支持类比继续使用ad-hoc函数更有意义.我希望有很多C++库,但我不想牺牲我习惯的速度和功能.

具体来说,我希望能够使用整数角度,我想保持这样的近似值提供的超快速度:

static inline int32_t sin_approx(int32_t angle)
//Angle is -32768 to 32767: Return -32768 to 32767
{
    return (angle<<1) - ((angle*abs(angle))>>14);
}

所以,在我不必要地推出自己的之前,是否有任何真正快速的c ++定点库,其中包含模板类,例如向量,我可以指定所用整数的宽度,并且具有快速近似值,例如上面的那个,我应该看一下？

我如何在C++中完成以下任务,以及这样做的事情是什么？

template <bool S>
class NuclearPowerplantControllerFactoryProviderFactory {
  // if S == true
  typedef int data_t;
  // if S == false
  typedef unsigned int data_t;
};

我打算问"如何挑选一个继承dict和定义的类__slots__".然后我意识到class B下面真正令人痛苦的解决方案确实有效......

import pickle

class A(dict):
    __slots__ = ["porridge"]
    def __init__(self, porridge): self.porridge = porridge

class B(A):
    __slots__ = ["porridge"]
    def __getstate__(self):
        # Returning the very item being pickled in 'self'??
        return self, self.porridge 
    def __setstate__(self, state):
        print "__setstate__(%s) type(%s, %s)" % (state, type(state[0]), 
                                                type(state[1]))
        self.update(state[0])
        self.porridge = state[1]

这是一些输出:

>>> saved = pickle.dumps(A(10))
TypeError: a class that defines __slots__ without defining __getstate__ cannot be pickled
>>> b = B('delicious')
>>> b['butter'] = 'yes …

除了为了正确性而绕过任何实例属性之外,隐式特殊方法查找通常也会绕过__getattribute__()对象的元类的方法.

文档提到了特殊方法,例如__hash__,__repr__和__len__,我从经验中知道它也包括__iter__Python 2.7.

引用相关问题的答案:

"魔术__methods__()被特别对待:它们被内部分配到类型数据结构中的"插槽"以加速他们的查找,并且只在这些插槽中查找."

为了改善我对另一个问题的回答,我需要知道:具体来说,我们在谈论哪些方法？

我正在写一些音频代码,基本上所有东西都是微小的循环.我理解它们的分支预测失败是一个足够大的性能问题,我很难保持代码分支免费.但是到目前为止,只有这一点可以带我,这让我想知道不同种类的分支.

在c ++中,条件分支到固定目标:

int cond_fixed(bool p) {
    if (p) return 10;
    return 20;
}

并且(如果我正确理解了这个问题),无条件分支到变量目标:

struct base {
    virtual int foo() = 0;
};

struct a : public base {
    int foo() { return 10; }
};

struct b : public base {
    int foo() { return 20; }
};

int uncond_var(base* p) {
    return p->foo();
}

是否存在性能差异？在我看来,如果两种方法中的一种明显比另一种方法快,编译器只会将代码转换为匹配.

对于分支预测非常重要的情况,有关性能的详细信息对于了解有用吗？

编辑:实际操作x : 10 ? 20只是一个占位符.分支之后的实际操作至少足够复杂,以至于两者都是低效的.此外,如果我有足够的信息可以合理使用__builtin_expect,在这种情况下,分支预测将不是问题.

以下代码段以3种方式执行相同的操作.

use std::collections::HashMap;

struct Foo {
    cache: HashMap<String, String>,
}

impl Foo {
    fn get_cached(&mut self, key: &String) -> &String {
        if !self.cache.contains_key(key) {
            self.cache.insert(key.clone(), String::from("default"));
        }
        self.cache.get(key).unwrap()
    }
    fn show_impl(&self, what: &String) {
        println!("{}", what);
    }
    pub fn show1(&mut self, key: &String) {
        println!("{}", self.get_cached(key));
    }
    pub fn show2(&mut self, key: &String) {
        if !self.cache.contains_key(key) {
            self.cache.insert(key.clone(), String::from("default"));
        }
        self.show_impl(self.cache.get(key).unwrap());
    }
    // This does not compile
    pub fn show3(&mut self, key: &String) {
        self.show_impl(self.get_cached(key));
    }
}

fn main() {} …

使用malloc和free,很容易为结构分配超出最终的额外数据.但我如何用new/ 完成相同的操作delete？

我知道我可以使用放置新语法以及malloc分配部分,但delete如果我将一个对象放在由分配的内存中,它将正常工作并且可移植malloc吗？

我想要完成的是与以下示例相同,但使用new/ delete而不是malloc/ free,以便正确调用构造函数/析构函数:

#include <cstdlib>
#include <cstring>
#include <iostream>

class Hamburger {
  int tastyness;
 public:
  char *GetMeat();
};

char *Hamburger::GetMeat() {
    return reinterpret_cast<char *>(this) + sizeof(Hamburger);
}

int main(int argc, char* argv[])
{
   Hamburger* hb;
   // Allocate a Hamburger with 4 extra bytes to store a string.
   hb = reinterpret_cast<Hamburger*>(malloc(sizeof(Hamburger) + 4));
   strcpy(hb->GetMeat(), "yum");
   std::cout << "hamburger …

以下三段代码实现了完全相同的效果.然而,当在GCC 4.5.2上使用-O3编译时,许多迭代的时间变化非常明显.

1 - 正常分支,使用多个条件,最佳时间1.0:

// a, b, c, d are set to random values 0-255 before each iteration.
if (a < 16 or b < 32 or c < 64 or d < 128) result += a+b+c+d;

2 - 分支,手动使用按位或检查条件,最佳时间0.92:

if (a < 16 | b < 32 | c < 64 | d < 128) result += a+b+c+d;

3 - 最后,在没有分支的情况下获得相同的结果,最佳时间为0.85:

result += (a+b+c+d) * (a < 16 | b < 32 | c < 64 | d …