小编Nim*_*Nim的帖子

有一点背景,我们有一个相当大的代码库,它构建在一组库中 - 然后分发供各种二进制文件内部使用.目前,为此构建过程是随意的,一切都是从主干建立起来的.

我们想探讨是否有一个构建系统可以让我们管理版本并自动引入依赖关系.这样的工具适用于java,Maven.我喜欢它的包,存储库和依赖机制,我知道使用maven-native或maven-nar插件我们可以得到它.然而问题是我们无法将源树修复为"maven方式" - 不幸的是(至少maven-nar)插件似乎不喜欢没有这种结构的代码......

所以我的问题是,是否有一个满足以下C++的工具

1. 建立
2. 包(例如包含所有头的库,类似于.nar)
3. 将包上传到"存储库"
4. 自动从所述存储库中提取所需的依赖项,提取标题并包含在构建,提取库和链接中.依赖关系将在该二进制文件的"发行版"中描述 - 因此,如果我们使用CI服务器构建该"发布",则构建脚本将列出必要的依赖项(如pom.xml文件).

我可以通过修改make + shell脚本或使用额外的python模块waf/scons进行打包和依赖管理来自己动手 - 但是我会认为这是一个常见的问题,某个地方有人有这个工具吗？或者每个人都自己动手？或者我错过了waf/scons或CMake的重要功能？

编辑:我应该补充一点,OS是首选,非MS ...

在回答这个问题时,我在模板实例化方面遇到了这种行为差异.

最初有一个功能模板

template <typename T> void my_callback(void* data) { … }

现在有些东西需要这个地址 - 特别是a void*,所以显而易见的方法是

bar(reinterpret_cast<void*>(&my_callback<int>));

但是,对于gcc 4.5之前的编译器版本,这会导致上下文错误...错误.好 - 所以修复是先"强制转换" - 强制实例化,即:

void (*callback)(void*) = my_callback<int>;
bar(reinterpret_cast<void*>(callback));

这很好用.

现在是第二种情况,它不是一个自由函数,而是一个类模板的静态成员,即

template <typename T>
struct foo
{
  static void my_callback(void* data) {
    T& x = *static_cast<T*>(data);
    std:: cout << "Call[T] with " << x << std::endl;
  }
};

现在,原作reinterpret_cast好了.

bar(reinterpret_cast<void*>(&foo<int>::my_callback));

所以我的问题是 - 为什么这种明显的行为差异？

我有这个难题,我试图解决,从根本上归结为以下示例:

template <typename CT>
struct A
{
  typedef typename CT::VALUE_T FOO; // FOO is dependent on CT
};

template <typename CT>
struct B
{
  typedef typename CT::BAR BAR;

  BAR foo() {}
};

template <typename DT>
struct C : B<C<DT> >
{
  typedef DT VALUE_T;

  typedef typename A<C>::FOO BAR;
};

int main () {
  C<int> c;
}

我可以尝试解释上面的内容(我已经尝试了三次并删除了文本!),但基本上要求是:

1. C必须从Btyped with C(利用CRTP)继承,即B<C<>>
2. C是唯一可以实例化的A(即A必须输入C)
3. A是唯一可以定义的FOO(FOO取决于类型CT …

(我确实扫描了,但是找不到任何类似的东西,如果请尽快关闭).

有没有办法阻止这两个运营商被继承？例如:

struct foo{
  static void* operator new(std::size_t) { 
    // special
  }
  static void operator delete(void* p, std::size_t) { 
    // special
  }
};    

struct bar : public foo {
};

现在bar将继承这两个操作符 - 在这个简单的情况下,没有这么大的问题,如果有数据成员foo和bar(并且在我的情况下更糟糕,因为foo需要以不同bar的方式完成分配!)现在要避免的方法出现问题就是这样bar,我也会实现运营商.但是,如果有很多派生类型,那么忘记覆盖某个地方的可能性是非常有可能的.所以问题是,有没有办法阻止这些运营商被继承？

注意:c ++ 03(如果特定于gcc,愿意接受一些特定于编译器的解决方案)

将first_name和last_name存储在2个单独的列中是否更好？

或者将两个存储在一列是否可以？

问题看起来很简单,基本上我有一系列序列,如:

typedef mpl::vector<
  mpl::vector<mpl::_1, mpl::_2>,
  mpl::vector<mpl::_1, mpl::_2, mpl::_3>,
  mpl::vector<mpl::_2, mpl::_1>,
  mpl::vector<mpl::_2, mpl::_2>,
  mpl::vector<mpl::_2, mpl::_2, mpl::_3>
> seq;

我想做的是将其转换为trie,最终结果如下:

mpl::map<
  mpl::pair<mpl::_1, 
    mpl::map<
      mpl::pair<mpl::_2,
        mpl::map<
          mpl::pair<TERMINAL, T>,
          mpl::pair<mpl::_3,
            mpl::map<
              mpl::pair<TERMINAL, T>
            >
          >
        >
      >
    >
  >
  mpl::pair<mpl::_2, 
    mpl::map<
      mpl::pair<mpl::_1,
        mpl::map<
          mpl::pair<TERMINAL, T>
        >
      >,
      mpl::pair<mpl::_2,
        mpl::map<
          mpl::pair<TERMINAL, T>,
          mpl::pair<mpl::_3,
            mpl::map<
              mpl::pair<TERMINAL, T>
            >
          >
        >
      >
    >
  >
>

所以,问题是,这是否可能(我认为不是)？如果有可能,我错过了哪些黑暗法术？

编辑:在情况下,从序列的序列中的上述变换到一个线索是不明确的,让我看看是否可以用简单的英语(通常更为困难.)基本上是主序列中的每个序列由某些类型的(STATE它_1,_2等.)转换后的版本是trie,其中公共前缀被折叠.可能是附图有助于..

EDIT2:感谢@Yakk,希望现在问题更清楚......

我一直试图让 ThreadSanitizer 与我拥有的 gcc 版本（4.8.2）一起工作，所以我拿了他们的简单例子：

#include <pthread.h>
#include <stdio.h>
#include <string>
#include <map>

typedef std::map<std::string, std::string> map_t;

void *threadfunc(void *p) {
  map_t& m = *(map_t*)p;
  m["foo"] = "bar";
  return 0;
}

int main() {
  map_t m;
  pthread_t t;
  pthread_create(&t, 0, threadfunc, &m);
  printf("foo=%s\n", m["foo"].c_str());
  pthread_join(t, 0);
}

并在没有 的情况下编译它-fsanitize=thread，如下所示：

g++ -o testtsan testtsan.cpp -lpthread

这很好，然后我添加了线程消毒剂

g++ -o testtsan testtsan.cpp -lpthread -fsanitize=thread

但是当然这失败了 -pie -fPIC

g++ -o testtsan testtsan.cpp -lpthread -fsanitize=thread -pie -fPIC

然后编译，但是在运行时，我得到：

FATAL: ThreadSanitizer CHECK failed: ../../../../libsanitizer/sanitizer_common/sanitizer_allocator.h:310 …

以下是我试图开始工作的代码：

>>> import asyncio
>>> async def foo(loop, iv):
...     await asyncio.sleep(1, loop=loop)
...     print(f'done: {iv}')
...     
>>> loop = asyncio.get_event_loop()
>>> loop.call_later(2, foo, loop, 10)
<TimerHandle when=36395.554089349 foo(<_UnixSelecto...e debug=False>, 10) at <input>:1>
>>> loop.run_forever()

（Python 3.6）

基本上该foo()函数有一些链式async调用，所以这个方法必须async是await链式调用的需要。但是这个方法是延迟触发的，运行这段代码，出现如下问题：

/usr/lib64/python3.6/asyncio/events.py:127: RuntimeWarning: coroutine 'foo' is never awaited self._callback(*self._args)

在 中处理此async调用的正确方法是call_later什么？

我正在寻找一个能够存储微秒粒度的Date对象,有人知道吗？标准Date对象只存储到毫秒(我知道这是一个平台限制),我可以通过Date在自定义类中包含一个加号小数量来解决这个问题.但是我希望避免使用适当的计算等来编写一个.我需要解析boost::ptimeJava中的时间戳并且不会丢失精度...

因此,我们使用的供应商提供了一个库(主要用于C,具有一些C++支持),它执行以下操作:

#ifndef int64_t
#define int64_t s_int64
#endif
#ifndef int32_t
#define int32_t s_int32
#endif
#ifndef int16_t
#define int16_t s_int16
#endif
#ifndef int8_t
#define int8_t  s_int8
#endif

在他们的图书馆深处的一个标题中.现在的问题是,一旦他们的库被包含在简单的C++ 11代码中,例如:

#include <iostream>

#include <vendor/library.h>

int main(void)
{
  std::int32_t std_i = 0;
  return std_i;
}

立即出现编译错误(s_int32不在std::).所以问题是,除了唠叨供应商这个解决方案之外,还有什么方法可以在我们的代码中解决这个问题？(顺便说一句.我尝试过的东西,#include <cstdint> 在它们的标题之前,没有运气; extern "C"包装,没有运气.标题安装在/usr/include/所以无法控制包含的顺序我猜...)