小编use*_*168的帖子

我想要标准库容器的 C++ 概念的实现。

提前谢谢了！

我正在寻找一个自我碎片整理的内存管理器,其中一个简单的递增堆分配器与一个简单的压缩碎片整理程序结合使用.

粗略的方案是从最低内存地址开始向上分配块,并保持从最高内存地址开始向下工作的簿记信息.

内存管理器会传回智能指针 - boost的intrusive_ptr似乎对于簿记结构最为明显,这些结构本身会指向实际的内存块,从而提供一个间接级别,以便可以轻松地移动块.

碎片整理程序将从"生成"书签开始压缩堆,以加快进程并且一次只对固定数量的内存进行碎片整理.对块本身的原始指针在下一次碎片整理通过之前是有效的,因此可以自由传递直到这样的时间改善性能.

具体应用是控制台游戏编程,因此在每个帧的开始或结束时,可以相对安全地完成碎片整理传递.

所以我的问题是,任何人都使用这种分配方案与STL结合,它会让STL分开,因为我怀疑.我可以看到std :: list <intrusive_ptr>在intrusive_ptr级别工作,但是stl列表节点本身的分配是什么,无论如何都要覆盖next/prev指针为intrusive_ptr本身,或者我只需要有一个标准堆分配器旁边这个更动态的.

我想在UNIX类型平台上用C++实现COM的自定义实现,以允许我动态加载和链接面向对象的代码.我认为这将基于POSIX提供的类似功能集来加载和调用dll,即dlopen,dlsym和dlclose.

据我所知,COM的一般思想是你链接到一些函数,即QueryInterface,AddRef和Release in a common dll(Kernel32.dll),然后允许你访问接口,这些接口只是一个用指针封装的函数指针表应该调用函数指针的对象.这些函数通过IUnknown公开,你必须继承它.

那一切都有用吗？有没有更好的方法来动态链接和加载到面向对象的代码？如何从dll继承工作 - 对基类的每次调用都必须是暴露的成员函数,即private/protected/public是否被忽略？

我非常精通C++和模板元编程,并且已经拥有一个完全反映的C++系统,即成员属性,成员函数和使用boost的全局/静态函数.

嗨,我在选择具有明确特化的模板化类的正确版本时遇到问题.我想要使​​用用于专门化的类的派生类来选择特化.场景是:

#include <stdio.h>

class A
{};

class B: public A
{};

template<typename T>
class Foo
{
public:
   int FooBar(void) { return 10; }
};

// Explicit specialization for A
template<> int Foo< A >::FooBar( void ) { return 20; }

void main( void)
{
   Foo<B> fooB;

   // This prints out 10 instead of wanted 20 ie compiler selects the general version
   printf("%d", fooB.FooBar() );
}

正如我在评论中所说的那样,我希望看到20被打印出来,因为B是从A派生出来的,而10则是打印出来的.如何在不诉诸为每个派生类编写专门化的情况下调用专门化(我的实际场景有很多派生类型).

我正在使用gcc和-finline-functions优化发布版本.为了对抗代码膨胀,因为我在嵌入式系统上工作,我想说不要内联特定的功能.这样做的显而易见的方法是通过函数属性即属性(noinline).问题是,当我打开作为-O3开关一部分的全局-finline-functions优化时,这似乎不起作用.

它也与它被模板化有关,因为同一函数的非模板化版本没有内联,这是预期的.

有没有人知道如何在这个全局开关打开时控制内联？

这是代码:

#include <cstdlib>
#include <iostream>

using namespace std;

class Base
{
public:

    template<typename _Type_>
    static _Type_ fooT( _Type_ x, _Type_ y ) __attribute__ (( noinline ));
};

template<typename _Type_>
_Type_ Base::fooT( _Type_ x, _Type_ y )
{
    asm("");
    return x + y;
}


int main(int argc, char *argv[])
{
    int test = Base::fooT( 1, 2 );
    printf( "test = %d\n", test );

    system("PAUSE");
    return EXIT_SUCCESS;
}

有没有人知道STL实现允许在使用之前将动态分配器传递给容器的实例.

方案是我们有一个通用内存分配器来管理许多内存池,并且对于我们想要从不同内存池分配每个实例的stl :: vector的每个实例.

标准STL实现的问题在于您只能在类型基础上定义内存池,即int类型的所有向量都将从同一个池中分配.

我已经将我们的默认stl :: allocator换成了一个有状态的那个,即我们想要分配这个实例的池,但这对于stl :: list来说效果不好,它在默认的ctor中分配东西.

由于与我们的库相关的原因,我们在ctor中没有所有对象的有效池,因此我们想在用户可以使用stl容器之前调用'set memory pool'函数.

有没有人遇到过支持这种事情的实现？

在VC2012中我是一个奇怪的人我似乎无法弄清楚通过const引用将const指针传递给模板化参数的函数的语法,模板参数是非常量指针,即:

template<typename T>
struct Foo
{
    void Add( const T& Bar ) { printf(Bar); }
};

void main()
{
Foo<char*> foo;
const char* name = "FooBar"; 
foo.Add(name);                 // Causes error
}

所以我在这里简化了我的问题,但基本上我希望参数'Add'有一个const T即const char*.我试过了:

void Add( const (const T)& Bar ); 

typedef const T ConstT;
void Add( const (ConstT)& Bar );  

void Add( const typename std::add_const<T>::type& Bar ); 

这些都不起作用.我得到的确切错误是:

error C2664: 'Foo<T>::Add' : cannot convert parameter 1 from 'const char *' to 'char *const &'
          with
          [
              T=char *
          ] …

好的,我想用C++编写一个精确的'标记和扫描'垃圾收集器.我希望做出一些可以帮助我的决定,因为我的所有指针都将包含在'RelocObject'中,并且我将为堆提供一个单独的内存块.这看起来像这样:

// This class acts as an indirection to the actual object in memory so that it can be      
// relocated in the sweep phase of garbage collector
class MemBlock
{
public:
    void* Get( void ) { return m_ptr; }

private:
    MemBlock( void ) : m_ptr( NULL ){}

    void* m_ptr;
};

// This is of the same size as the above class and is directly cast to it, but is     
// typed so that we can easily debug the underlying …

我想知道是否有办法找出一个类是否是另一个类的直接基础,即在Boost类型特征术语中是一个is_direct_base_of函数.据我所知,Boost似乎不支持这种功能,这使我认为使用当前的C++标准是不可能的.

我想要的原因是对两个用于反射系统的宏进行一些验证检查,以指定一个类是从另一个派生的,如下面的示例代码所示.

header.h:

#define BASE     A
#define DERIVED  B

class A {};
class B : public A 
{
   #include <rtti.h>
};

rtti.h:

// I want to check that the two macro's are correct with a compile time assert
Rtti<BASE, DERIVED> m_rtti;

虽然在这个简单的例子中宏看起来是不必要的,但在我的真实场景中,情况rtti.h要复杂得多.

一种可能的途径是将this指针的大小与转换为基类型的this指针的大小进行比较,并以某种方式试图弄清楚它是否是基类本身的大小或其他东西.(是的,你是对的,我不知道那是怎么回事!)

我在Windows上,我正在用VS2008构建一个C++项目.我正在尝试替换new/delete/malloc/free等.这是有效的,即我的替换被调用.

但是我的替换分配器需要初始化.到目前为止,我已经将它定义为.cpp文件中的全局变量,并在其中定义了#pragma init_seg(lib).

直到最近std :: locale开始初始化时才开始工作,这在我的分配器初始化之前调用了new.所以我紧张地将我的allocator的全局变量移动到编译器段,即#pragma init_seg(编译器).

这工作了一点,然后我决定覆盖malloc.现在我在_tmainCRTStartup中的__crtGetStringTypeA_stat中获得了一个malloc调用,甚至在编译器段中的全局变量已经初始化之前.

有没有办法让我的变量在CRT启动之前被实例化.我唯一能想到的是重建我的crt lib并尝试一些如何在那里插入我的初始化代码.我认为必须有一个crt清理功能？

是否有更容易的途径和/或我在这里缺少的明显的东西？

好吧,我正在通过这样做来缓存内存中的文件

byte[] file = System.IO.File.ReadAllBytes("test.xml");

然后我会尝试从该缓冲区创建一个xml文档,如下所示:

System.IO.MemoryStream stream = new System.IO.MemoryStream(file);
System.Xml.XmlTextReader reader = new System.Xml.XmlTextReader(stream);
System.Xml.Linq.XDocument xPartDocument = new System.Xml.Linq.XDocument(reader); 

但这无法创建具有以下异常的文档:

A first chance exception of type 'System.ArgumentException' occurred in System.Xml.Linq.dll

Additional information: Non white space characters cannot be added to content.

Run Code Online (Sandbox Code Playgroud)

然而,'读者'看起来不对,即在本地人中它有'无'作为值:

• reader {None} System.Xml.XmlTextReader

'file'字节数组变量有11个字节,看起来像标题(我假设这只是txt文件头？):

0x0393B148  58 35 59 71  X5Yq 
0x0393B14C  dc 67 01 00  Üg.. 
0x0393B150  ef bb bf 3c  < 
0x0393B154  3f 78 6d 6c  ?xml 
0x0393B158  20 76 65 72   ver

任何帮助非常感谢.

谢谢

我使用InterlockedExchange编写了一个基本的自旋锁(见下文).但是我已经看到很多实现使用InterlockedCompareExchange.以某种不可预见的方式是不正确的,如果不是,每种方式的专业和缺点是什么(如果确实有的话)？

PS我知道睡眠是昂贵的,我想在我打电话之前尝试计数.

class SpinLock
{
public:

    SpinLock() : m_lock( 0 ) {}
    ~SpinLock(){}

    void Lock()
    {
        while( InterlockedExchange( &m_lock, 1 ) == 1 )
        { 
            Sleep( 0 ); 
        }
    }

    void Unlock()
    {
        InterlockedExchange( &m_lock, 0 );
    }

private:
    volatile unsigned int m_lock;
};

嗨,我正在使用C++创建一个类似字典对象的C#.我使用类似的垃圾收集ref对象系统,用于在程序运行时在内存中移动的所有内容.我开始实现字典一个非常标准的哈希表,这很好,我有这种类型的布局:

header + hash table -> storage -> element 0 -> object x
                                  element 1 -> object y
                                  element ... -> object ...

'+': In same allocation 
'->': Indirect pointer ie different allocation

所以'header'只包含表格大小.'哈希表'是存储区域中的整数偏移数组.

存储被实现为C#列表,即到自调整数组的间接指针(ref对象),即像C++向量.

Dictionary::Element存储器中的每个元素()都包含一个id,一个到实际对象的间接指针(ref对象)和一个到下一个元素的整数偏移量.

// C++ like pseudo code:
template< typename _Type_, typename _HashType_ = int >
class Dictionary
{
private:

   class Element
   {
       _HashType_ m_id;
       _Type_     m_object;   // Ref object ie indirect pointer to actual object
       int        m_next;     // Next element
   }

   int            m_tablesize; // Power …