标签: standards

在下面的源代码中,有人可以解释理性(为什么使用新名称typedef对结构_lwm2m_object_t进行良好的编程实践lwm2m_object_t？它只是删除下划线？为什么在第一个实例中使用下划线？

typedef struct _lwm2m_object_t lwm2m_object_t;

typedef uint8_t (*lwm2m_read_callback_t) (lwm2m_uri_t * uriP, char ** bufferP, int * lengthP, lwm2m_object_t * objectP);
typedef uint8_t (*lwm2m_write_callback_t) (lwm2m_uri_t * uriP, char * buffer, int length, lwm2m_object_t * objectP);
typedef uint8_t (*lwm2m_execute_callback_t) (lwm2m_uri_t * uriP, char * buffer, int length, lwm2m_object_t * objectP);
typedef uint8_t (*lwm2m_create_callback_t) (lwm2m_uri_t * uriP, char * buffer, int length, lwm2m_object_t * objectP);
typedef uint8_t (*lwm2m_delete_callback_t) (uint16_t id, lwm2m_object_t * objectP);
typedef void (*lwm2m_close_callback_t) (lwm2m_object_t …

当函数需要返回两个参数时,可以使用std :: pair编写它:

std::pair<int, int> f()
{return std::make_pair(1,2);}

如果你想使用它,你可以这样写:

int one, two;
std::tie(one, two) = f();

这种方法的问题是你需要定义'one'和'two'然后将它们分配给f()的返回值.如果我们能写出类似的东西会更好

auto {one, two} = f();

我看了一个演讲(我不记得哪一个,对不起),演讲者说C++标准的人试图做那样的事情.我认为这个讲座是从2年前开始的.有谁知道现在(几乎是c ++ 17)你能做到或类似吗？

有一篇文章AsyncFunction - MDN上的JavaScript.它显示以下代码段:

new AsyncFunction([arg1[, arg2[, ...argN]],] functionBody)

然而,在Mozzila Firefox 55和Google Chrome中,这个构造函数根本没有定义:

我发现(async function() {}).constructor确实如此AsyncFunction,但为什么我不能在全球范围内看到它呢？

假设我有一个安装packages(profile::base::tools)的类和另一个定义profile::base::yum这些包所需的yumrepos()的类.

tools.pp:

class profile::base::tools {
   $packages = [
      'package1',
      'package2'
   ]

   package { $packages:
     ensure => present,
   }
}

目前它的运行方式是通过base.pp:

base.pp:

include profile::base::yum 
include profile::base::tools

Class['profile::base::yum'] -> [
    Class['profile::base::tools']]     

所以当我运行base.pp它时首先创建yum repos然后安装包.目前,tools.pp首先要求yumrepos定义的依赖关系仅在提及中提及base.pp.

我的问题是,如果我tools.pp单独运行(出于测试目的),它不会知道依赖性,因此会失败.我可以添加include profile::base::yum在tools.pp类,但想知道如果为每个类标准的了解的依赖,即使它已经在别处定义的(像base.pp)

我一直在问自己，临时对象是否确实具有身份。我知道以下内容是有效的：

object.temporary_object().modify()

只要返回的对象是非常量对象，或者对象上调用的函数都不会修改不可变成员。

根据值类别的定义，prvalue的结果可以移动但没有标识，并且由于Temporary Objects是prvalue表达式的结果，如何修改它们？

C++标准多次使用单词适配器:

• 分配器适配器(std::scoped_allocator_adaptor)
• 容器适配器(std::queue,std::priority_queue,std::stack)
• 迭代器适配器(std::reverse_iterator,std::move_iterator)

似乎这个词本身并没有在标准中定义.我认为这个词用于参考设计模式,但似乎在适配器设计模式中,适配器应该只调整接口,而不是行为.

问题:因此我想知道:

• C++标准中适配器的近似定义是什么？
• 它是否与适配器设计模式相对应？
• 如果没有,那么与C++标准(适配器,代理,外观,装饰器......)中的适配器最匹配的设计模式是什么？

C++ 17标准27.2.1.8说:

迭代器j被称为可以从迭代器i到达,当且仅当存在表达式++ i的有限序列的应用程序时才使i == j.

也就是说,任何符合标准的迭代器类型都必须提供operator ==.

但是,我发现没有任何关于operator !=迭代器类型的要求.

是否operator !=必须为给定的迭代器类型提供C++标准要求？

在C++中,如果我声明一个类/结构:

struct Data
{
    int member0;
    int member1;
};

在大多数编译器中,member0在对象表示中出现的比较早member1.

标准是否要求这种行为,或者理论上是否允许编译器放在对象表示member1之前member0？
标准对此有何看法,它在哪里说出来？
(如果强制行为在任何时候发生了变化,我对所有标准版本感兴趣.)

根据工作中的领导，两者之间的区别

if (invalid) {
   ...some code
}

if (!invalid) {
  ...some code
}

和

if (invalid) {
  ...some code
} else {
  ...some code
}

可以理解为一种风格选择。我想知道人们在哪里划线以及您会如何考虑这一点。

PS：是的，我知道否定不应该是 if 语句的“名义”情况。请忽略这一点，因为我试图完全复制引发讨论的相关代码。

Let's say I have a piece of code like this:

// Foo.h:
class Incomplete; // the forward-declaration
class Foo {
  void bar(Incomplete&); // doesn't really matter
};

// Foo.cpp:
class Incomplete : private Baz {
};
void Foo::bar(Incomplete&) {
}

Is forward-declaring classes like in Foo.h standard-compliant? If it is, since which language version? What about the same for protected inheritance?