到目前为止,我知道#include Qt类的几种方法：

> #include< QtModule>

这将带来特定模块的所有类,例如QDomDocument,QDomElement,QDomNode以及#include< QtXml>中的许多其他类.
> #include< QClassName>

这增加了可能想要使用的特定类的声明,例如,QEvent,QStringList,QFile.
> #include< qcstyleheader.h>

这具有前一方法的效果,除了不同的标题名称.

所以我想知道,还有其他方法可以#include Qt课程吗？它们是否相同,或者由于某些原因,它们中的一些是否优先于其他人？这取决于.cpp或.h文件中的#include-ing？这会影响可执行文件的编译速度和大小吗？

简而言之,最好的方法是什么？

通常,头文件越多,编译器解析每个模块所需的时间就越长. (显然,预编译的头文件会产生一些问题.)因此,您通常希望包含正确构建应用程序所需的最少头文件.

如果您只在给定的编译单元中使用几个类,那么只需按现代风格的名称包含类：

#include <QEvent>#include <QPainter>#include <QFont>

如果您使用给定模块中的大量类,则可能同样容易包含模块级标头,例如：

#include <QtGui>

如果不存在较新的样式标题,通常只使用较旧的.h样式.

现在,预编译的头文件通过编译成二进制形式来缓解许多这些问题.但是,将预编译符号加载到内存中并在编译时搜索它们仍然需要付出代价.因此,您投入的越少,构建的效率就越高.

我有一个基类

class Animal

使用纯虚函数和一组派生类

class Monkey : public Animal 
class Snake : public Animal

我想实现一个比较操作,以便在我的代码中遇到两个指向动物的指针

Animal* animal1
Animal* animal2

我可以将它们相互比较.如果animal1和animal2具有不同的派生类别,则比较应该产生错误.如果它们具有相同的派生类,则应返回比较运算符的输出.

有人能指出我实现这个的好方法吗？

哇,很多其他答案都是如此完全没必要. dynamic_cast-它存在,使用它.

class Animal {
public:
    virtual bool operator==(const Animal& other) = 0;
    virtual ~Animal() = 0;
};
template<class T> class AnimalComp : public Animal {
public:
    virtual bool operator==(const Animal& ref) const {
        if (const T* self = dynamic_cast<const T*>(&ref)) {
            return ((T*)this)->operator==(*self);
        }
        return false;
    }
    virtual bool operator!=(const Animal& ref) const {
        if (const T* self = dynamic_cast<const T*>(&ref)) {
            return ((T*)this)->operator!=(*self);
        }
        return true;
    }
};
class Monkey : public AnimalComp<Monkey> {
public:
    virtual bool operator==(const Monkey& other) const {
        return false;
    }
    virtual bool operator!=(const Monkey& other) const {
        return false;
    }
};
class Snake : public AnimalComp<Snake> {
public:
    virtual bool operator==(const Snake& other) const {
        return false;
    }
    virtual bool operator!=(const Snake& other) const {
        return false;
    }
};

编辑：在我的自动模板实现之前鞠躬！

编辑编辑：我做的一件事就是忘记将它们标记为const,这对我来说是错误的.我不会为不做而道歉！=因为,让我们面对现实,实施它是一件轻而易举的事.

更多编辑：耶稣基督家伙,这不是如何写的例子！=或==,这是如何使用CRTP的一个例子.如果你不喜欢我选择实施我的！=或==,你可以起诉.

我有一个方法,它使用任务和async / await重复工作.

public static Task ToRepeatingWork(this Action work,int delayInMilliseconds)
    {
        Action action = async () =>
        {                
            while (true)
            {
                try
                {
                    work();
                }
                catch (MyException ex)
                {
                    // Do nothing
                }
                await TaskEx.Delay(new TimeSpan(0,delayInMilliseconds));
            }
        };
        return new Task(action,SomeCt,TaskCreationoptions.LongRunning);
    }

我写过相应的测试：

[TestMethod,TestCategory("Unit")]
    public async Task Should_do_repeating_work_and_rethrow_exceptions()
    {
        Action work = () =>
        {
            throw new Exception("Some other exception.");
        };

        var task = work.ToRepeatingWork(1);
        task.Start();
        await task;
    }

我期待这个测试失败,但它通过(并崩溃测试运行器).

但是,如果在ToRepeatingWork方法中,我将操作从异步更改为正常操作并使用等待而不是等待,则测试将按预期运行.

TaskEx.Delay(new TimeSpan(0,delayInMilliseconds)).Wait();

这有什么不对？

你永远不应该使用任务构造函数.如果您有工作要放在线程池上,请使用Task.Run.这是一个问题,但不是导致崩溃的原因.

您还应该避免异步void,因此请使用Func< Task>而不是行动.这就是导致崩溃的原因.

public static Task ToRepeatingWork(this Action work,int delayInMilliseconds)
{
  Func<Task> action = async () =>
  {                
    while (true)
    {
      try
      {
        work();
      }
      catch (MyException ex)
      {
        // Do nothing
      }
      await TaskEx.Delay(new TimeSpan(0,delayInMilliseconds));
    }
  };
  return Task.Run(() => action());
}

[TestMethod,TestCategory("Unit")]
public async Task Should_do_repeating_work_and_rethrow_exceptions()
{
  Action work = () =>
  {
    throw new Exception("Some other exception.");
  };

  var task = work.ToRepeatingWork(1);
  await task;
}

我认为下面的代码会让所有10个线程一次运行两个,然后在调用Release()10次后打印“done”.但那不是发生了什么：

int count = 0;

        Semaphore s = new Semaphore(2,2);
        for (int x = 0; x < 10; x++)
        {
            Thread t = new Thread(new ThreadStart(delegate()
            {
                s.WaitOne();
                Thread.Sleep(1000);
                Interlocked.Increment(ref count);                       
                s.Release();
            }));
            t.Start(x);
        }

        WaitHandle.WaitAll(new WaitHandle[] { s });
        Console.WriteLine("done: {0}",count);

输出：

done: 6

如果实现我正在寻找的功能的唯一方法是将EventWaitHandle传递给每个线程,然后对那些EventWaitHandles的数组执行WaitAll(),那么在仅数组上执行WaitAll()的含义是什么信号量？换句话说,等待线程何时解除阻塞？

WaitHandle.WaitAll(new WaitHandle [] {s});等待s.WaitOne();.它在第一次机会进入.您似乎希望此调用等待所有其他信号量操作,但操作系统无法区分它们.此命令可能是第一个被授予访问信号量的命令.

我认为你需要的是障碍课.它用于fork-join-style并行.