小编She*_*evy的帖子

以下代码是否合法(在c ++ 11/14中)？

bool foo() {
  union bar { int i; bool b; };
  union baz { char c; bar b; };
  auto b = baz{'x'};
  auto barptr = &b.b;
  auto boolptr = &barptr->b;
  new (boolptr) bool{true};
  return b.b.b;
}

这个例子很愚蠢,但是我正在使用一个可变参数variant实现,它使用嵌套联合而不是char []变量成员的块,并且允许这将使我当前在复制构造函数中的尝试变得更清晰.

将其分解为两个子问题:

1. 是否boolptr通过访问barptr合法成员进行分配b.b是不活跃的？
2. 是否有就地构建boolptr激活b.b和b.b.b？

可以参考该标准.

在linux上,使用gcc 4.8.4,使用-std = c ++ 11 -mcx16编译:

#include <atomic>

struct node_t;

struct pointer_t {
        node_t* ptr;
        unsigned int count;
        pointer_t() noexcept : ptr{nullptr}, count{0} {}
};

struct empty {};

struct node_t {
        empty value;
        std::atomic<pointer_t> next;
        node_t() : next{pointer_t{}} {}
};

int main() {
        node_t{}.next.load();
        return 0;
}

在load调用时给出段错误.我是怎么想初始化原子值的？

std::unique_ptr在http://en.cppreference.com/w/cpp/memory/unique_ptr上阅读,我的天真印象是,一个足够聪明的编译器可以unique_ptr用裸指针替换正确的使用,并delete在unique_ptrs被破坏时放入.实际情况如此吗？如果是这样,任何主流优化编译器实际上都这样做了吗？如果没有,是否可以编写一些具有部分/全部unique_ptr编译时安全优势的东西,这些优点可以优化以便没有运行时成本(空间或时间)？

注意那些(正确地)担心过早优化:这里的答案不会阻止我使用std::unique_ptr,我只是好奇它是一个非常棒的工具还是只是一个很棒的工具.

编辑2013/07/21美国东部时间20:07:

好的,所以我测试了以下程序(请告诉我这是否有问题):

#include <climits>
#include <chrono>
#include <memory>
#include <iostream>

static const size_t iterations = 100;

int main (int argc, char ** argv) {
    std::chrono::steady_clock::rep smart[iterations];
    std::chrono::steady_clock::rep dumb[iterations];
    volatile int contents;
    for (size_t i = 0; i < iterations; i++) {
        auto start = std::chrono::steady_clock::now();
        {
            std::unique_ptr<int> smart_ptr(new int(5));
            for (unsigned int j = 0; j < UINT_MAX; j++)
                contents = *smart_ptr;
        }
        auto middle …

我知道字典不会按照添加它们的顺序存储它们的键值对,但是如果我将相同的键值对(可能以不同的顺序)添加到两个不同的字典并序列化结果,那么数据将存档是相同的？

编辑:为了澄清,我要具体询问GetObjectData()的输出,而不是任何特定的序列化器.请考虑以下代码:

Dictionary<string,List<string>> dict1 = new Dictionary<string,List<string>>();
Dictionary<string,List<string>> dict2 = new Dictionary<string,List<string>>();
string key11 = "key1";
string key12 = "key1";
string key21 = "key2";
string key22 = "key2";
List<string> values11 = new List(1);
List<string> values12 = new List(1);
List<string> values21 = new List(1);
List<string> values22 = new List(1);
values11.add("value1");
values12.add("value1");
values21.add("value2");
values22.add("value2");
dict1.add(key11, values11);
dict2.add(key22, values22);
dict1.add(key21, values21);
dict2.add(key12, values12);

dict1和dict2会为GetObjectData()返回相同的东西吗？如果没有,为什么不呢？

TimeLog可以是开票还是不开票,而发票包含许多时间日志.我们的数据库不能有可空的外键,所以我们使用的是连接模型.代码:

class TimeLog < ActiveRecord::Base
  has_one :invoices_time_logs
  has_one :invoice, through: :invoices_time_logs
end

class Invoice < ActiveRecord::Base
  has_many :invoices_time_logss
  has_many :time_logs, through: :invoices_time_logss
end

class InvoicesTimeLogs
  belongs_to :invoice
  belongs_to :time_log
end

Invoice.first.time_logs.build工作正常,但TimeLog.first.build_invoice给出

NoMethodError:#TimeLog:0x4acd588>的未定义方法`build_invoice'

是不是has_one应该使build_association方法可用？

更新:

我为这个问题做了一个样本回购:build_assocation_test.要查看问题,请克隆存储库,安装捆绑包,运行迁移(或加载架构),然后在rails控制台中:

Invoice.create
Invoice.first.time_logs.build
TimeLog.create
TimeLog.first.build_invoice

我正在开发一个程序,它将一个重要的数据结构存储为一个带有程序定义分隔符的非结构化字符串(所以我们需要遍历字符串并提取我们需要的信息)并且我们想将它转换为更结构化的数据类型.

本质上,这将需要一个结构,其中一个字段描述结构包含哪种数据,另一个字段是一个包含数据本身的字符串.在分配时始终知道字符串的长度.我们通过测试确定,每种数据类型所需的分配数量加倍是不可接受的成本.有没有办法在单个分配中为结构和结构中包含的std :: string分配内存？如果我们使用cstrings,我只需要在struct中有一个char*,并在为块和字符串分配足够大的块之后将其指向结构的末尾,但是如果可能的话我们更喜欢std :: string.

我的大部分经验都是使用C,所以请原谅这里显示的任何C++无知.

我了解如何将类型为SCM_RIGHTS的辅助数据用于在Linux上的进程之间发送文件描述符。但是所有IEEE Std 1003.1-2008都必须说：

SCM_RIGHTS

Indicates that the data array contains the access rights to be sent or received.

Run Code Online (Sandbox Code Playgroud)

这意味着什么？SCM_RIGHTS类型的辅助数据有任何可移植的含义吗？

来自ISO/IEC 14882:2011(E)(C++ 11)的§17.6.4.9:

除非另有明确说明,否则以下各项适用于C++标准库中定义的函数的所有参数.
[snip]
- 如果函数参数绑定到右值引用参数,则实现可以假定此参数是对此参数的唯一引用.

该规范仅适用于标准库函数,但似乎rvalue引用的全部要点是这种假设是可能的.如果我有一个带rvalue引用的函数并将其传递给一个(通过临时或者std::move),那么实现是否可以合法地执行假设它是唯一的优化？如果没有,那么任何实现都是这样做的吗？

我期待通过n3690，即将到来的选秀C++14标准，我在看节7.2段9：

如果两个枚举类型具有相同的基础类型，则它们是布局兼容的。

但是，我找不到任何说明枚举类型与其基础类型布局兼容的内容。对我来说，考虑到“基础类型”的含义，这应该遵循合理的语义，这似乎很明显，但标准是否真的保证了这一点？

假设我有以下模板:

template <typename T> union example {
    T t;

    constexpr example(const T & t) : t(t) {};

    /* We rely on owning class to take care
     * of destructing the active member */
    ~example() {};
};

由于那里的析构函数,example<T>永远不会是简单的可破坏的(因此不是一个文字类型).我想要像我这样的部分专业化

template <typename T> union
    example<std::enable_if_t<std::is_trivially_destructible<T>::value, T>> {
    T t;

    constexpr example(const T & t) : t(t) {};
};

让它example<T>在任何时候T都是可以轻易破坏的,但不幸的是,这给了我(合理的,事后的)警告

警告:类模板部分特化包含一个无法推导出的模板参数; 永远不会使用这种部分专业化

那么有什么方法可以得到我想要的东西吗？