小编Dan*_*Dan的帖子

我在递归C++程序中分配和释放内存时遇到问题.因此,如果不使用自动内存管理解决方案,我想知道是否有人可以帮我解决我遇到的内存泄漏问题.

以下代码基本上解释了问题(尽管这是一个人为的例子,请纠正我所犯的任何错误或简化).

一个数字类,用于保存数字的值:

class Number {
    public:
        Number() { value = 1; };
        Number& operator + (const Number& n1) const {
            Number result = value + n1.value;
            return result;
        };
        int value;
};

执行递归的两个函数:

Number& recurse(const Number& v1) {
    Number* result = new Number();
    Number one = Number();
    *result = *result + recurse(one);
    return *result;
}

int main(...) {
    Number answer = Number();
    answer = recurse(result);
}

正如你所看到的那样,recurse函数中分配的内存被泄露了,但我不确定在哪里可以根据递归的性质释放这些内存？

这应该是一个相当微不足道的问题.我正在尝试使用std :: string(或std :: wstring)打开一个ofstream,并且在没有混乱转换的情况下遇到问题.

std::string path = ".../file.txt";

ofstream output;

output.open(path);

理想情况下,如果有更好的方法,我不想手动转换它或涉及c风格的char指针？

使用此代码:

#include <fstream>

#include <boost/archive/text_oarchive.hpp>

using namespace std;

int main()
{
    std::ofstream ofs("c:\test");
    boost::archive::text_oarchive oa(ofs);
}

我在运行时在执行boost存档行时遇到未处理的异常:

boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::archive::archive_exception> >

如何动态地找出从类的实例定义了哪些函数？

例如:

class A(object):
    def methodA(self, intA=1):
        pass

    def methodB(self, strB):
        pass

a = A()

理想情况下,我想找出实例'a'有methodA和methodB,以及它们采用哪些参数？

我正在尝试使用现有dict的值列表作为单独的键创建新的dict.

例如:

dict1 = dict({'a':[1,2,3], 'b':[1,2,3,4], 'c':[1,2]})

我想获得:

dict2 = dict({1:['a','b','c'], 2:['a','b','c'], 3:['a','b'], 4:['b']})

到目前为止,我还没能以非常干净的方式做到这一点.有什么建议？

在实例方法中指向类方法显然会导致问题:

class A(dict):          
    def __getitem__(self, name):
        return dict.__getitem__(self, name)

class B(object):
    def __init__(self):
        self.a = A()
        B.__getitem__ = self.a.__getitem__ 

b1 = B()
b1.a['a'] = 5
b2 = B()
b2.a['b'] = 10

c = b1['a']
d = b2['b']

给出了这个错误:

  File ... in __getitem__
    return dict.__getitem__(self, name)
KeyError: 'a'

我应该在这做什么呢？

我的输入浮点值为0.0f <=值<1​​.0f(注意小于1).

当将该值乘以更大的范围时,浮点精度自然会降低,这意味着该值可能会超出等效范围.

例如,如果我开始使用如下值:

0.99999983534521f

然后将它乘以100,我得到:

100.000000000000f

哪个没问题,但是如何将浮点表示减少到最接近的浮点值仍然小于100？

我发现了这个小手工技巧:

union test
{
    int integer;
    float floating;
};

test value;

value.floating = 1.0f;

printf("%x\n", value.integer);

然后我取出那个十六进制值并将其减少一个十六进制数字,然后明确地设置它:

unsigned int almost_one = 0x3f7fffff;

float value = 1.0f;

if (value >= 1.0f)      std::memcpy(&value, &almost_one, sizeof(float));

这适用于这个特定的值,但是我可以使用更通用的方法吗？

我希望有一个神奇的指令,我不知道我可以用它来实现这个目标!

编辑:这里有很多答案,std :: nextafter看起来就像我追求的那样.不幸的是我还不能使用C++ 11数学库,所以这对我不起作用.为了节省复杂的事情,我将用C++ 11标记这个问题并接受Mike的答案.

我已经为C++ 03开始了一个新问题:替代C++ 11的std :: nextafter和std :: nexttoward for C++ 03？

我将大多数用户使用的简单正则表达式格式转换为正确的re python正则表达式字符串的最简单方法是什么？

作为一个例子,我需要转换这个:

string = "*abc+de?"

对此:

string = ".*abc.+de.?"

当然,我可以遍历字符串并按字符构建另一个字符串,但这肯定是一种低效的方法吗？

我正在尝试使用两个const参数创建一个重写的运算符函数,但我无法弄清楚如何做到这一点.这是一个简单的例子:

class Number
{
    Number()
    {
        value = 1;
    };

    inline Number operator + (const Number& n)
    {
        Number result;

        result.value = value + n.value;
        return result;
    }

    int value;
}

我在这里尝试做的是将两个参数传递给另外的函数,这两个参数都是const并返回结果而不更改类中的任何内容:

const Number a = Number();
const Number b = Number();
Number c = a + b;

这是可能的,我将如何做到这一点？

谢谢,

担

在python中散列层次结构(类似于文件结构)的好方法是什么？

我可以将整个层次结构转换为虚线字符串,然后将其哈希,但有没有更好(或更有效)的方式来做到这一点,而不是一直来回？

我可能想要散列的结构示例如下:

a -> b1 -> c -> 1 -> d
a -> b2 -> c -> 2 -> d
a -> c -> 1 -> d

为什么如下:

class A(object):
    def __init__(self, var=[]):
        self._var = var
        print 'var = %s %s' % (var, id(var))

a1 = A()
a1._var.append('one')

a2 = A()

造成:

var = [] 182897439952
var = ['one'] 182897439952

我不明白为什么在使用可选关键字参数时它没有使用列表的新实例,有人能解释一下吗？

我正在尝试使用我想要执行特定函数的特化来对类进行子类化.但是,当我将它存储在列表中时,C++会隐式地将我的类转换为它的基类.显然,列表可以存储类的任何子类,所以这是可以接受的,但是如何存储类以便我可以访问这个特定的函数.

我能想到这样做的唯一方法是使用模板,还有其他选择吗？

这是一个例子:

class A
{
    A() {}
    virtual void function()
    {
    }
}

class B : public A
{
    B() {}
    void function()
    {
    }
}

boost::shared_ptr<B> b = boost::shared_ptr<B>(new b);
std::list<boost::shared_ptr<A> > objects;
objects.push_back(b);

// pull t out of objects

t.function();

编辑:过度简化了这一点,所以我修了几件事......