小编AMC*_*der的帖子

我想知道是否存在自动注册类类型的设计模式或习惯用语.或者更简单,我可以通过简单地扩展基类来强制一个方法来调用类吗？

例如,假设我有一个基类Animal和扩展类Tiger和Dog,和我有打印出扩展的所有类的辅助功能Animal.

所以我可以这样:

struct AnimalManager
{
   static std::vector<std::string> names;
   static void registerAnimal(std::string name) { 
            //if not already registered
            names.push_back(name); }
};

struct Animal
{
   virtual std::string name() = 0;
   void registerAnimal() { AnimalManager::registerAnimal(name()); }
};
struct Tiger : Animal
{
   virtual std::string name() { return "Tiger"; }
};

基本上我会这样做:

Tiger t;
t.registerAnimal();

这也可以用于static函数.是否有任何模式(如奇怪的递归模板)或类似的东西可以帮助我实现这一点,而无需显式调用该registerAnimal方法.

我希望class Animal将来可以扩展,其他人可能会忘记打电话register,我正在寻找方法来防止这种情况,除了记录这一点(无论如何).

PS这只是一个例子,我实际上并没有实施动物.

以下示例中会发生什么？

struct B { };
struct D1 : B  { };
struct D2 : B  { };
int main()
{
    D1 d;
    D2 d2;
    B& x = d;
    x = d2;
}

我知道引用没有重新分配.x仍然指的是d,但是你怎么分配d2给d？

多一点:

struct B
{
    B () { x = 0; }
    int x;
    virtual void foo () { cout << "B" << endl; }
};
struct D1 : B
{
    D1 () { x = 1; }
    virtual void …

首先,这不是关于精度或类似问题的问题.

我的问题是,编译器如何决定如何表示数字？

我们以C为例.我写

double d = 4.5632;

它如何选择二进制表示？我知道它没有完全代表,所以它如何选择最接近的可表示数字？它是在编译时完成的吗？它是由CPU还是操作系统完成的？

请,如果你知道这是如何发生只能回答,就像回答"不担心"也没有什么帮助.此外,"它取决于平台"也没有帮助,你可以选择一个平台并解释.

完全披露 - 我的灵感来自Is x + =比x = x + a更快？

这且不说,我决定测试+=VS -=.简单的测试表明它们大致相同.然后我尝试了类似的东西:

std::vector<int> x;
for (int i = 0 ; i < 10000 ; i++)
   x.push_back(rand()%10);

并调用+=和-=按比例给定的数字:

long long sum = 0;

for ( each number in the array )
    if ( x[j] < k )
        sum += x[j];
    else
        sum -= x[j];

所以,如果k是小的-=话会更频繁地被召唤(duuuh).我试过用k = 2它来提供更高比例的-=被叫,并且k = 5,它应该产生大约相同数量的-=和+=. …

我编写了以下代码来测试这个:

struct X
{
   char* x;
   X()
   {
      x = new char('a');
   }
   ~X()
   {
      *x = 'b';
      delete x;
   }
};

void foo(const X& x)
{
}
void goo(X& x)
{
}

int main()
{
   foo(X());
   goo(X());
}

两个函数退出后调用临时函数的析构函数,但我认为你只能将临时函数绑定到const引用.为什么goo工作呢？

是UB和MSVS是错的,还是没问题？

所以我做了以下测试:

char* a = "test";
char* b = "test";
char* c = "test\0";

现在的问题是:

1)有保证a==b吗？我知道我在比较地址.这并不是要比较字符串,而是将相同的字符串文字存储在单个内存位置

2)为什么不a==c呢？编译器是否应该能够看到它们引用相同的字符串？

3)是否\0附加了额外的内容c,即使它已经包含一个？

我不想为此提出3个不同的问题,因为它们似乎有点相关,对不起'.

注意:标签是正确的,我对C++感兴趣.(虽然请指明C的行为是否不同)

C++中是否有一个带O(1)查找的数据结构？

A std::map有O(log(n))查找时间(对吗？).

我从std优先考虑的事情(所以不是Boost pls).此外,如果有,它是如何工作的？

编辑:好的,我猜不清楚.我想关联价值观,有点像map.所以我想要类似的东西std::map<int,string>,find并且insert应该采取O(1).

如果我加载DLL LoadLibrary,该DLL是否保证保持加载？如果没有,我该如何防止重新加载.

实际情况:我有一个调度程序,根据一些消息,需要加载几个dll中的一个并从中执行一些功能.我无法在编译时链接它们,所以我使用LoadLibrary.因为可能会有很多电话,所以我不想LoadLibrary每次都打电话,因为事实证明它是一个瓶颈.所以我想每个DLL只调用一次,每个dll只调用一次GetProcAddress函数,然后将它缓存到某个地方.但它安全吗？我保证在任何后续通话中调用该功能都可以吗？如果没有,我怎么能有这个保证？

您可以&在类中重载一元运算符:

struct X
{
   void* operator &()
   {
      return this;
   }
};

这样它就会返回一个地址.你会如何在课外重载它:

struct X
{
};

void* operator &(const X& x)
{
    //how?
}

获取参数的地址将导致无限递归.

以下代码不会调用复制构造函数.

struct X
{
   int x;
   X(int num)
   {
      x = num;
      std::cout << "ctor" << std::endl;
   }
   X(const X& other)
   {
      std::cout << "copy ctor" << std::endl;
   }
};

int main(int argc, _TCHAR* argv[])
{
   X* x = new X(3);
   X* y(x);
}

输出:

ctor

是复制品吗？