小编Dan*_*Dan的帖子

在这个简单的例子中,为什么我需要创建'member'const以便编译它？

struct ClassA
{
    ClassA(int integer) {}
};

struct ClassB
{
    ClassB(int integer):
        member(integer)
    {
    }

    const ClassA& member;
};

int main()
{
    ClassB* b = new ClassB(12);

    return 0;
}

否则,我收到此错误:

错误:从类型'int'的表达式初始化类型'ClassA&'的引用无效

我有一个抽象类在c ++中定义一个纯虚方法:

class Base
{
Base();
~Base();

virtual bool Test() = 0;
};

我已经将其子类化了许多其他类(它们为Test()提供了一个实现),我将其称为A,B,C等.我现在想要使用这个创建任何这些类型的数组基类:

int main(int argc, char* argv[])
{
    int size = 0;
    Base* bases = new Base[10];

    bases[size++] = new A();
    bases[size++] = new B();

    for (int i = 0; i < size; i++)
    {
        Base* base = bases[i];
        base->Test();
    }
}

(请原谅我可能犯的任何错误,我正在写这篇文章提供一个简单的例子).

问题是我无法实例化数组,因为它需要创建一个Base类的实例(它不能像它的抽象那样做).但是,如果不这样做,它就没有分配分配给数组索引所需的内存,因此在尝试访问该内存时会提供分段错误.我的印象是,将new和delete与malloc和free混合起来并不是一个好习惯.

可能是我混淆了应该使用它的方式,我应该尝试使用模板或其他一些机制来做到这一点,但希望我提供了足够的信息来说明我正在尝试做什么.

那么这样做的最佳方法是什么？如何解决将内存分配给抽象类的问题？

谢谢,丹

如何在python中配置涉及self和arguments的调用？

def performProfile(self):
    import cProfile
    self.profileCommand(1000000)

def profileCommand(self, a):
    for i in a:
        pass

在上面的例子中,我将如何描述对profileCommand的调用？我想我需要使用runctx作为参数,但我该如何处理self？(代码实际上涉及UI,因此很难单独调用配置文件).

这里发生了什么:

printf("result = %d\n", 1);
printf("result = %f\n", 1);

输出:

result = 1
result = 0.000000

如果我在尝试打印它们之前确保这些变量的类型,它当然可以正常工作.为什么第二个print语句没有被隐式转换为1.00000？

我将在某些背景下提到这个问题:

flex/lex中字符串文字的正则表达式

我遇到的问题是在我的词法分析器中使用转义字符处理输入,我认为这可能与字符串的编码有关,但我不确定.

这是我在lexer中处理字符串文字的方式:

\"(\\.|[^\\"])*\"
{                   
    char* text1 = strndup(yytext + 1, strlen(yytext) - 2);
    char* text2 = "text\n";

    printf("value = <%s> <%x>\n", text1, text1);
    printf("value = <%s> <%x>\n", text2, text2);
}

这输出如下:

value = <text\n"> <15a1bb0>
value = <text
> <7ac871>

它似乎将换行符分别视为反斜杠后跟n.

这里发生了什么,如何处理文本与C输入相同？

关于python的一个非常好的事情是,你可以简单地命名与访问者同名的变量:

self.__value = 1

def value():
    return self.__value

是否有一种简单的方法来提供对我希望子类化的类的私有成员的访问？通常我希望简单地使用类中的原始数据对象,而不必一直使用访问器和变换器.

我知道这似乎违背了私有和公共的一般概念,但通常我尝试子类的类是我自己的类,我很乐意将成员公开给子类但不公开该类的实例.有没有一种干净的方式来提供这种区别？

这是一个非常人为的例子,因为要解释我最终实现这个解决方案的背景并不容易.但是,如果有人能够回答为什么会发生这种特殊情况,我将不胜感激.

这个例子:

class A(dict):  
    def __init__(self):
        self['a'] = 'success'

    def __getitem__(self, name):
        print 'getitem'
        return dict.__getitem__(name)

class B(object):
    def __init__(self):
        self._a = A()
        setattr(self, '__getitem__', self._a.__getitem__) 

b = B()
c = b['a']

这输出:

c = b['a']
TypeError: 'B' object is unsubscriptable

即使这是一种奇怪的方式(显然子类化更合乎逻辑),为什么它找不到我明确设置的方法？

如果我这样做:

dir(b)

我明白了:

['__class__', '__delattr__', '__dict__', '__doc__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', '__weakref__', '_a']

其他方法也会出现同样的问题__iter__.明确定义这个有效的方法是什么意思？

我有一个简单的库为我生成标题,我希望在Makefile中将它链接在一起.

如果cpp文件包含不存在的头文件,它应该从匹配的源文件生成它(如果相应的文件存在).我无法弄清楚如何做到这一点.

我已经尝试使用gcc -MM提前找出每个.cpp文件的依赖关系,但如果缺少标头,则会失败.我需要知道哪些文件丢失以尝试重新生成它们.

如果我只是定义了一个标题prequisite所有.cpp文件,它总是会重新编译所有的,当然我的.cpp文件.

有关如何重新生成缺少的标头的任何想法？

我有一个像这样的库提供的课程:

template <typename T>
class TypedClass
{
public:
    typedef typename boost::shared_ptr<TypedClass<T> > Ptr;

    T m_data;
    T* m_pointer_data;
};

假设我愿意接受int和float在这个特定体系结构上总是相同的大小(和对齐),这似乎对我有用:

TypedClass<int>* int_object = new TypedClass<int>();

TypedClass<float>* float_object = reinterpret_cast<TypedClass<float>* >(int_object);

现在我正在尝试使用boost shared_ptrs来实现相同的功能,并提出了这个:

TypedClass<int>::Ptr int_object = TypedClass<int>::Ptr(new TypedClass<int>());

void* int_object_void_pointer = reinterpret_cast<void*>(int_object.get());

TypedClass<float>::Ptr float_object(reinterpret_cast<TypedClass<float>*>(int_object_void_pointer));

这似乎工作正常,但这种共享指针的使用将导致对象被删除两次,我想避免.

需要注意的是,'TypedClass'是第三方库的一部分,并且该库使用共享指针来实现其所有内部功能,因此我需要这种形式的数据.我之前已经解决了从boost enable_shared_from_this继承的问题,但这不可能.

这是一种简单的技术,尝试将相同的对象重用于具有相同大小的数据类型,而无需使用新类型分配新对象.

建议欢迎.

我正在尝试使用带有三个有符号整数作为键的 unordered_map （这是因为我希望使用 tbb 的并发_unordered_map）。

我将这个小（3x16 位=> 64 位）函数放在一起：

// to hash

int64_t result = int16_t(x);

result = int64_t(result << 16) + int16_t(y);
result = int64_t(result << 16) + int16_t(z);

// from hash

int16_t x_ = int16_t(result >> 32);
int16_t y_ = int16_t(result >> 16);
int16_t z_ = int16_t(result & 0xFFFF);

这不起作用，我在这里犯了什么错误？

我的数字分布是这样的，接近零的负数或正数更有可能（通常小于 +/- 2^8），但我想将其扩展到最大 2^32 的范围，而不是我的2^16 的例子在这里。理想情况下，我正在寻找典型范围内的很少的碰撞，并且最好是一个简单的算法。有什么建议么？