小编vam*_*msi的帖子

我正在阅读有关访客模式的内容,它看起来像Double Dispatch.两者之间有什么区别吗？这两个术语是否意思相同.

参考:http://www.vincehuston.org/dp/visitor.html

我正在阅读各种IPC机制.我试图弄清楚场景,我们使用共享内存和我们使用命名管道(FIFO)的地方.

管道:多个进程可以写入,但只有一个进程可以读取.写操作是原子的.

共享内存:多个进程可以读写.并且用户还需要提供互斥以进行读写.

这是共享内存和管道应用的唯一区别吗？

class Base
{
   public:
   virtual void func() const
   {
     cout<<"This is constant base "<<endl;
   }
};

class Derived : public Base
{
   public:
   virtual void func()
   {
     cout<<"This is non constant derived "<<endl;
   }
};


int main()
{
  Base *d = new Derived();
  d->func();
  delete d;

  return 0;
}

为什么输出打印"这是常数基数".但是,如果我删除func()的基本版本中的const,它会打印"这是非常量派生"

d-> func()应该正确调用Derived版本,即使Base func()是const右边的吗？

找到以单调方式增加然后单调减小的序列中的最大值或最小值可以在O(log n)中完成.

但是,如果我想检查一个数字是否存在于这样的序列中,那么这也可以在O(log n)中完成吗？

我不认为这是可能的.考虑这个例子:1 4 5 6 7 10 8 3 2 0.

在这个例子中,如果我需要查找序列是否包含'2',我没有任何条件将搜索空间划分为原始搜索空间的一半.在最糟糕的情况下,它将是O(n),因为当我们试图搜索2时你需要检查两半.

我想知道,如果这个搜索是在O(log n)时间完成的吗？

我需要在linux中的线程的信号队列中找到待处理信号的数量.是否有Linux提供的API？

除了我们查询的线程之外,需要从线程调用此API.

sigpending给出了调用线程的API.是否有任何API,它将线程ID作为arg,并提供有关队列中待处理信号的一些信息.

任何帮助表示赞赏.

Class B;
B *b  = new B();       // default constructor
B *b1 = new B(10);     // constructor which takes an argument B(int x)

但是,如果我们要编写自定义版本new,则语法为

Class B
{
  /*...*/
  static void* operator new(size_t size);
}

如何将语句new B()转换为函数调用 operator new(sizeof(B))？

它如何跟踪调用哪个构造函数,即它如何区分new B()和new B(int x)？

被new实现为C++中的宏？

我有多个使用信号灯进行通信的进程。

sem_open("\name",O_CREATE,S_IRWXU|S_IRWXG,10);

我有以下两个问题：

1. 现在，当一个进程突然死亡而没有调用sem_close或sem_unlink时。其余过程会怎样？

2. 如果调用了sem_close（），则不会为1个进程调用sem_unlink（）。所有其他进程都调用sem_close（）和sem_unlink（）。所有进程退出后，信号灯是否仍然存在？

A类（比如说），只有静态成员函数，B类（比如说）只有成员函数

如果我创建类 A 的 1000 个实例。由于该类仅包含静态成员函数，因此即使有 1 个或 1000 个实例，内存也不会增加。

但是，对于 B 类。如果我创建 1000 个实例，是否会增加内存（即使是最轻微的，可能是每个对象指向成员函数集的指针）？

如果不是，那么编译器如何跟踪特定对象的成员函数信息？

#include <iostream>
#include <string.h>
using namespace std;

class A
   {
     private:
  int a;
  int b;
  public:
  A():a(10),b(20){};
  A(int ad,int bd):a(ad),b(bd){};
  void printvalues()
  {
        cout<<a << " " <<b<<endl;
  }
};

int main()
{

  A a(5,12);

  memset(&a,sizeof(A),0);
  a.printvalues();

  return 0;
}

将对象设置为0,似乎对对象没有任何影响.任何人都可以帮助我理解这种行为.输出:5 12

我想有一个函数指针数组,每个指向一个不同的函数.该函数在原型和参数数量方面也可能不同.

我在C/C++中寻找以下类似的功能.

以下代码在C中无法编译

#include <stdio.h>

typedef int (*FUNC)(int a,int b);

int func_one(int a)
{
   printf("\n In function 1 with 1 parameter %d \n",a);
   return 1;
}

int func_two(int a,int b)
{
   printf("\n In function 2 with 2 parameter %d %d \n",a,b);
   return 2;
}

typedef struct{
FUNC fnc;
enum type{ ONE,TWO} type_info;
}STR;

int main()
{
STR str[2];
int ret;
int i;

str[0].fnc = func_one;
str[0].type_info = ONE;

str[1].fnc = func_two;
str[1].type_info = TWO;


for(i=1;i>=0;--i)
{
   if(str[i].type_info == ONE)
      ret …

可能重复:
使用虚拟构造函数的位置？

为什么我们需要在C++中使用虚拟构造函数？

虽然C++不直接支持它.有几种解决方案可以实现此功能.我想知道,当我们需要这样的事情时.

class B
{

private:
int _x;
public:
int get(){return _x;};
B(int x=10):_x(x){cout<<"Default constructor "<<endl;}
~B(){cout<<"destructor "<<endl;}
B(const B &rhs){cout<<"copy constructor"<<endl;}
B& operator =(const B &rhs){cout<<"copy assignment operator"<<endl;}
int operator *(){cout<<"operator *"<<endl;return _x;}
};

int main()
{
vector<B> v;
int i;
vector<B>::iterator ii=v.begin();

for(i=0;i<1;i++)
{
 v.push_back(*(new B(i*100)));
}
ii = v.begin();
cout<<"#####################"<<endl;
ii = v.insert(ii+1,*(new B()));
cout<<"#####################"<<endl;

return 0;
}

输出:

   Default constructor 
   copy constructor
   #####################
   Default constructor 
   1. copy constructor
   2. copy constructor
   destructor 
   #####################
   destructor 
   destructor 

为什么在v.insert(ii,*(new B()));,两个拷贝构造函数被调用？