通常使用多个单词来实现bignums,但我想尽可能地选择单词大小.这比看起来更棘手 - std::uint64_t在许多32位编译器中都可用,但std::uint32_t在32位机器上可能是更好的选择.那么诱惑就是使用std :: size_t,但不能保证给定的体系结构std::size_t是最有效的算术类型,例如在新的x32 Linux ABI std::size_t上将是32位但std::uint64_t仍然是最佳选择.
C++ 11定义了各种大小的快速/最小类型,但它没有提供任何查询它们相对性能的方法.我意识到可能没有最好的可移植答案,我现在最好的猜测是std::size_t在配置时默认并检测出特殊的架构.但也许有更好的方法？
boost :: intrusive文档描述了如何使用带有侵入式容器的智能指针,但后来说你不能使用你最有可能使用的智能指针,"它必须具有与原始指针相同的所有权语义.意味着不能使用资源管理智能指针(如boost :: shared_ptr)."
为什么是这样？我想不出他们应该被禁止的任何明显理由.究竟会打破什么？侵入式容器无论如何都不管理其中的项目分配.在我的情况下,我想使用intrusive_ptr,但我没有看到为什么shared_ptr不应该工作的任何原因.
编辑:要清楚,我的意思是钩子指针(例如,侵入式单链表中的下一个指针)是一个智能指针.
我正在尝试定义一个has_ostream_operator<T>SFINAE测试,以检查我是否可以cout一个给定的类型.我有它工作,但只有在我的定义中has_ostream_operator我称之为operator<<方法而不是作为中缀运算符.换句话说,这有效:
decltype(std::declval<std::ostream>().operator<<(std::declval<T>()))>
这不是:
decltype(std::declval<std::ostream>() << std::declval<T>())>
下面的测试用例(也可以参见http://coliru.stacked-crooked.com/a/d257d9d6e0f3f6d9).请注意,我包含了void_t的定义,因为我只在C++ 14上.
#include <iostream>
namespace std {
template<class...>
using void_t = void;
}
template<class, class = std::void_t<>>
struct has_ostream_operator : std::false_type {};
template<class T>
struct has_ostream_operator<
T,
std::void_t<
decltype(
std::declval<std::ostream>().operator<<(std::declval<T>()))>>
: std::true_type {};
struct Foo {};
template<class X>
void print(
const X& x,
std::enable_if_t<has_ostream_operator<X>::value>* = 0)
{
std::cout << x;
}
template<class X>
void print(
const X&,
std::enable_if_t<!has_ostream_operator<X>::value>* = 0)
{
std::cout << "(no ostream operator<< …据我了解，当您映射文件时，您基本上是将该文件的页面缓存中的页面直接映射到您的进程中，而当您使用 O_DIRECT 时，您将绕过页面缓存。将两者一起使用是否有意义？如果我的理解是正确的，它甚至会如何工作？mmap 似乎依赖于页面缓存中的文件，而 O_DIRECT 似乎阻止它进入那里（假设系统上没有其他任何东西打开了该文件）。我发现了这个问题，但回答者似乎认为这是完全正常的。
为了使我的emacs设置更便携,我希望能够通过指定文件而不是字体名称来设置当前字体,即"Load~/config/myfont.ttf并使用大小12".有没有办法在我的.emacs中做到这一点？我发现的所有说明都假定字体已经安装在系统上.我正在Linux上使用XFT支持,所以Linux特定的黑客行为可以,但我更喜欢能适用于所有目标的东西.
更新:要清楚,我使用的是Windows/OS X/Linux上不标准的字体.我不只是想基于平台设置不同的字体,而是指定我拥有的特定字体文件(TTF在Windows和Linux上工作,如果不在Mac上我会得到该文件的另一个版本,但我仍然想要通过文件而不是名称指定字体).
所以我看到很多文章现在声称在C++上双重检查锁定,通常用于防止多个线程尝试初始化一个懒惰的单例,被打破了.正常双重检查锁定代码如下所示:
class singleton {
private:
singleton(); // private constructor so users must call instance()
static boost::mutex _init_mutex;
public:
static singleton & instance()
{
static singleton* instance;
if(!instance)
{
boost::mutex::scoped_lock lock(_init_mutex);
if(!instance)
instance = new singleton;
}
return *instance;
}
};
问题显然是行分配实例 - 编译器可以自由分配对象,然后将指针分配给它,或者将指针设置为它将被分配的位置,然后分配它.后一种情况打破了这个习惯用法 - 一个线程可以分配内存并分配指针,但在它进入休眠状态之前不运行单例的构造函数 - 然后第二个线程将看到该实例不为null并尝试返回它,即使它尚未建成.
我看到了一个使用线程局部布尔值的建议并检查而不是instance.像这样的东西:
class singleton {
private:
singleton(); // private constructor so users must call instance()
static boost::mutex _init_mutex;
static boost::thread_specific_ptr<int> _sync_check;
public:
static singleton & instance()
{
static …singleton multithreading locking sequence-points double-checked-locking
对于非常低级别的优化目的,如果我可以将编译函数直接存储在变量中,而不是指向函数的指针,那将对我有用.也就是说,如果我有一个函数foo,我想创建一个足够大的char缓冲区来保存为foo生成的机器指令,然后能够通过某种方式告诉C将执行跳转到该缓冲区的内容来调用foo (假设我有一个编译器内在函数,以确保char缓冲区为我的架构正确对齐).理想情况下,我想这样做可以将组件使用保持在最低限度(我意识到可能需要一些).
到目前为止,我最好的解决方案是编译一个程序,它只具有我想用GCC组装的函数,然后编译成机器代码,然后使用输出组件中的地址从可执行文件中提取所需的机器代码,然后手动填充我的程序中的缓冲区,然后使用内联汇编跳转到缓冲区的起始地址.虽然这比我想要的更加虚伪和手工.
我不需要在运行时编译新函数,只需让缓冲区包含与运行时期间已编译的不同函数相对应的指令.例如,我可能有3个编译函数和1个缓冲区.这3个函数在编译时是已知的,但是在运行时,缓冲区可以在不同时间对应于3中的任何一个.
编辑:澄清会得到什么:我有一个结构,这个缓冲区将成为一个成员,以及各种指向该结构实例的指针.每个struct的缓冲区可能包含不同的编译函数.如果我使用函数指针而不是缓冲区,我将不得不加载struct的函数指针,然后deref函数指针.使用缓冲区,我可以将程序计数器跳转到结构基础的偏移量(缓冲区的相对位置).这是一个较少的间接水平.对于非常小的功能,这可以节省.
编辑2:进一步澄清:
使用函数指针:
使用包含机器代码的缓冲区:
第二个是较少的步骤.
我想出了一个问题的解决方案，但我不确定它是否总是有效或仅适用于我的编译器。首先，问题：我注意到在许多情况下，即使给定相同的类型，也希望每次使用时都重新实例化模板类（假设您的模板类具有初始化为函数调用的静态成员）有一些重要的副作用——并且您希望每次使用模板时都会产生这种副作用）。最简单的方法是给你的模板一个额外的整数参数：
template<class T, class U, int uniqueify>
class foo
{
...
}
但是现在您必须手动确保每次使用 foo 时都会为 uniqueify 传递一个不同的值。天真的解决方案是这样使用__LINE__：
#define MY_MACRO_IMPL(line) foo<line>
#define MY_MACRO MY_MACRO_IMPL(__LINE__)
不过这个解决方案有一个问题——__LINE__每个翻译单元都被重置。因此，如果两个翻译单元在同一行上使用模板，则模板只会实例化一次。这似乎不太可能，但想象一下，如果确实发生了编译器错误，那么调试它会有多困难。同样，您可以尝试__DATE__以某种方式用作参数，但它只有几秒钟的精度，而且是编译开始的时间，而不是到达该行的时间，因此如果您使用的是 make 的并行版本，则有两个翻译单元是相当合理的同__DATE__。
另一种解决方案是一些编译器有一个特殊的非标准宏，__COUNTER__它从 0 开始，每次使用时递增。但它遇到了同样的问题——每次调用预处理器都会重置它，因此它会重置每个翻译单元。
另一种解决方案是一起使用__FILE__和__LINE__：
#define MY_MACRO_IMPL(file, line) foo<T, U, file, line>
#define MY_MACRO MY_MACRO_IMPL(T, U, __FILE__, __LINE__)
但是您不能根据标准将字符文字作为模板参数传递，因为它们没有外部链接。
即使这确实有效，__FILE__标准中也没有定义是包含文件的绝对路径还是仅包含文件本身的名称，因此如果您在不同的文件夹中有两个相同的命名文件，这仍然可能会中断。所以这是我的解决方案：
#ifndef toast_unique_id_hpp_INCLUDED
#define toast_unique_id_hpp_INCLUDED
namespace {
namespace toast {
namespace detail {
template<int i>
struct translation_unit_unique {
static int …假设您在共享内存中有一个引用计数对象.引用计数表示使用该对象的进程数,进程负责通过原子指令递增和递减计数,因此引用计数本身也在共享内存中(它可以是对象的字段,也可以是对象可以包含指向计数的指针,如果他们协助解决这个问题,我愿意接受建议.有时,进程会有一个错误,阻止它减少计数.如何让它尽可能简单地确定哪个过程不会减少计数？
我想到的一个解决方案是给每个进程一个UID(可能是他们的PID).然后当进程递减时,他们将UID推送到与引用计数一起存储的链表上(我选择了一个链表,因为你可以原子地附加到CAS的头部).当您想要调试时,您有一个特殊的进程,它查看共享内存中仍然存在的对象的链接列表,并且列表中没有的任何应用程序的UID是尚未减少计数的那些.
该解决方案的缺点在于它具有O(N)存储器使用,其中N是进程的数量.如果使用共享内存区域的进程数很大,并且您有大量对象,则这很快就会变得非常昂贵.我怀疑有可能是一个中间解决方案,其中有部分固定大小的信息,您可以通过某种方式能够缩小可能的进程列表,即使你不能找出一个一协助调试.或者,如果你能发现它的过程还没有递减当只有一个单一的过程还没有(即无法处理2个或多个进程未能递减计数的检测),这将可能仍然是一个很大的帮助.
(这个问题有更多'人类'解决方案,比如确保所有应用程序使用相同的库来访问共享内存区域,但是如果共享区域被视为二进制接口,并且并非所有进程都是由你不能控制自己.而且,即使所有的应用程序使用相同的库,一个应用程序可能会在库外部出现一个破坏内存的错误,这样就不会减少计数.是的我正在使用不安全的语言C/C++;)
编辑:在单进程情况下,您将拥有控制权,因此您可以使用RAII(在C++中).
algorithm debugging multithreading reference-counting shared-memory
这有效:
>>> def bar(x, y):
... print x, y
...
>>> bar(y=3, x=1)
1 3
这有效:
>>> class Foo(object):
... def bar(self, x, y):
... print x, y
...
>>> z = Foo()
>>> z.bar(y=3, x=1)
1 3
甚至这个工作:
>>> Foo.bar(z, y=3, x=1)
1 3
但为什么这不起作用？
>>> Foo.bar(self=z, y=3, x=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method bar() must be called with Foo instance as first argument (got nothing instead)
这使得元编程更加困难,因为它需要特殊的案例处理.我很好奇Python的语义是否是必要的,或者仅仅是实现的工件.