相关疑难解决方法(0)

我正在使用libgc,一个用于C和C++的垃圾收集器.要使STL容器可以收集垃圾,必须使用gc_allocator.

而不是写作

std::vector<MyType> 

一个人必须写

std::vector<MyType,gc_allocator<MyType> >

可以有一种方法来定义类似的东西

template<class T> typedef std::vector<T,gc_allocator<T> > gc_vector<T>;

我前一段时间检查过,发现它不可能.但我可能错了,或者可能有另一种方式.

以这种方式定义地图尤其令人不快.

std::map<Key,Val> 

变

std::map<Key,Val, std::less<Key>, gc_allocator< std::pair<const Key, Val> > >

编辑:尝试使用宏后,我发现以下代码打破了它:

#define gc_vector(T) std::vector<T, gc_allocator<T> >
typedef gc_vector( std::pair< int, float > ) MyVector;

模板化类型定义中的逗号被解释为宏参数分隔符.

所以内部类/结构似乎是最好的解决方案.

这是一个如何在C++ 0X中完成的示例

// standard vector using my allocator
template<class T>
using gc_vector = std::vector<T, gc_allocator<T> >;

// allocates elements using My_alloc
gc_vector <double> fib = { 1, 2, 3, 5, 8, 13 };

// verbose and fib are of …

许多图书馆喜欢使用::new和使用::delete.

例子来自 boost::make_shared

template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T …

我有一个分配大量内存的应用程序,我正在考虑使用比malloc更好的内存分配机制.

我的主要选择是:jemalloc和tcmalloc.使用它们中的任何一个是否有任何好处？

在http://locklessinc.com/benchmarks.shtml中 ,一些机制(包括作者的专有机制 - 无锁)之间有一个很好的比较,它提到了每个机制的优点和缺点.

鉴于这两种机制都是积极的并且不断改进.有没有人对这两者的相对表现有任何见解或经验？

我确切地说,我将这个问题限制为我的x86(64位)linux盒子的"本机"开发.没有嵌入式或非x86架构.

由于我是C++用户并且有C++复兴,我目前正在使用C++进行个人项目.

现在我正在使用强大的,传统的linux/gcc/make工具链.

但通过博客文章和SO问题,我最近意识到了新的有前途的工具:

• ''clang''作为''gcc''的替代品,速度更快,提供更好的错误信息
• ''gold''代替''ld'',速度要快得多

这些工具鲜为人知,很容易甚至不知道它们.

还有其他有趣的鲜为人知的工具我应该注意吗？例如替代gdb等？(我也在使用cmake)

我首先寻找易于开发,然后提高开发速度.欢迎任何其他改进.

如果可能,免费工具.

我知道你可以超载操作员new.执行此操作时,size_t默认情况下会为方法发送一个参数.但是,是否可以将size_t参数 - 以及其他用户提供的参数 - 发送到重载的new运算符方法？

例如

int a = 5;
Monkey* monk = new Monkey(a);

因为我想覆盖这样的新运算符

void* Monkey::operator new(size_t size, int a)
{

...

}

谢谢

编辑:这是我想要完成的事情:

我在应用程序的开头(内存池)分配了一大块虚拟内存.继承我的基类的所有对象都将继承其重载的new运算符.我想有时在重载new中传递一个参数的原因是告诉我的内存管理器我是否要使用内存池,或者我是否想用malloc分配它.

我一直在尝试用c ++创建一个垃圾收集器,我已经将它设计为我的所有基类,称为garbageCandidate,它包含一个静态向量,其中包含指向garbageCandidate的指针,每个garbageCollector实例都在向量上推送"this" .

然后静态函数出现并删除静态向量中的所有指针.

在删除函数的最开始(删除第一个指针)我得到一个错误,说明删除被用于无效指针...

这与静态/动态绑定有关吗？我的意思是:删除操作符是否无法按预期行事,因为我在"父"类上调用delete并且它实际上是一个孩子？

一种避免这种情况的方法是创建虚拟析构函数吗？(或虚拟删除功能)？

还是我完全错过了什么？

ps:用于动态创建的测试的所有对象.

我们有一个提供C接口的库extern "C",并且是从C代码中使用的,但是它内部使用STL容器和一些C++功能(如RAII)以方便使用.

现在有一个新的要求,即库应该能够指向来自客户端代码的自定义malloc和free函数,并将其用于内部的分配.我可以将它们放入库的上下文结构中,并在需要的地方使用它们,但是将它们与STL一起使用是令人费解的......

我查看了allocator类,但似乎STL容器必须能够使用默认构造函数来创建分配器,似乎没有办法将这些指针放入它们中,让它们通过它们调用来进行分配.

是否有可能以线程安全的方式(不使用全局变量)来解决这个问题？

我真的没有得到模板std :: vector的字段,第一个指定类型,例如一个类,但我没有得到分配器,指针和引用变量.

我将提供一个简单的例子,我想使用类人的向量,所以我不得不对模板向量说:嘿,存储我一些人的,但我还必须告诉向量如何分配该类.(1)该示例的语法如何？

一些代码开头:

旁注,在人的构造函数中,c(2)我应该使用日期*？

class date
{
public:
    int m_nMonth;
    int m_nDay; 
    int m_nYear;

    int getMonth(return m_nMonth;)
    int getDay(return m_nDay;)
    int getYear(return m_nYear;)

    void setDate(int month, int day, int year)
    {
            m_nMonth=month;
            m_nDay=day;
        m_nYear=year;
    }

    date()
    {
        setDate(0,0,0);
    }

    date(int month, int day, int year)
    {
        setDate(month,day,year);
    }

    void printDate()
    {
        printf("%d/%d/%d", m_nMonth, m_nDay, m_nYear);
    }
}

class person
{
public:
    int m_nID;
    char m_sName[128];
    char m_sSurname[128];
    date m_cBirthDay;

    void setName(const char* name)
    { …

我发现自己经常不假思索地编写类,这些类添加指向对象的指针,这些对象后来被销毁到列表中,这导致了很多段错误,但问题是有时我根本无法提出比存储列表更好的解决方案指针.我认为,在C++中似乎没有一种简单的方法可以"存储你无法复制的临时对象".有没有关于如何有效地做到这一点的范例？

例如,我将有一个看起来像这样的类:

class MyClass
public:
   std::vector<OtherClass *> other_objects;
   void method() {
      OtherObject other_object = create_other_object();
      other_objects.push_back(&other_object);
   }

您可能想要这样做的一个原因是因为您使用other_objects其他地方(作为其他函数的参数)并且您无法复制OtherObject实例(例如,如果OtherObject复制构造函数是私有的,则可能会发生这种情况).

当然,一旦你尝试other_objects在代码中的其他地方使用,每个指针指向的内存将被破坏.

我写了很多的Python代码,我用这种结构非常频繁,其中一个方法填充的迭代与该方法的范围内单独存在的对象.有没有办法在C++中有效地做到这一点？我可以自己进行内存管理,以使方法中的临时对象保持活动超出方法范围吗？

我试图理解delete []的用法.以下代码是否会发生内存泄漏？

int * getArray( )
{
    int *r = new int[10];
    for (int i = 0; i < 10; ++i)
        r[i] = i;
    return r;
}

int main ()
{
    int *array;
    for ( int i = 0; i < 10; i++ ) // main loop
        array = getArray();
    return 0;
}

主循环似乎是为10个数组分配内存,其中只有最后一个数组有一个有效的指针.如果这是内存泄漏,我如何释放存储前9个阵列的内存？

我也可以用来const int r[10];代替编译int *r = new int[10];.可以使用const避免内存泄漏吗？