小编zvr*_*rba的帖子

在C++ 11中使用元组有什么好的用例？例如,我有一个定义本地结构的函数,如下所示:

template<typename T, typename CmpF, typename LessF>
void mwquicksort(T *pT, int nitem, const int M, CmpF cmp, LessF less)
{
  struct SI
  {
    int l, r, w;
    SI() {}
    SI(int _l, int _r, int _w) : l(_l), r(_r), w(_w) {}
  } stack[40];

  // etc

我正在考虑SI用一个替换结构std::tuple<int,int,int>,这是一个更短的声明,方便的构造函数和运算符已经预定义,但具有以下缺点:

• 元组元素隐藏在模糊的,实现定义的结构中.即使Visual Studio很好地解释和显示它们的内容,我仍然不能放置依赖于元组元素值的条件断点.
• 访问单个元组字段(get<0>(some_tuple))比访问struct元素(s.l)要冗长得多.
• 按名称访问字段比通过数字索引提供更多信息(并且更短!).

最后两点由tie函数解决.鉴于这些缺点,元组的用例是什么？

更新事实证明VS2010 SP1调试器无法显示以下数组的内容std::tuple<int, int, int> stack[40],但它在使用结构编码时工作正常.所以这个决定基本上是一个明智的选择:如果你必须检查它的值,使用一个结构[特别是.像GDB这样的调试器很重要].

经典算法书籍(TAOCP,CLR)(而不是经典算法书籍,如fxtbook)充满了命令式算法.对于其实现主要基于数组的算法而言,这是最明显的,例如组合生成(在算法中使用数组索引和数组值)或联合查找算法.

这些算法的最坏情况复杂性分析取决于数组访问是O(1).如果用array-ish持久性结构替换数组,例如Clojure,则数组访问不再是O(1),并且这些算法的复杂性分析不再有效.

这让我想到了以下问题:纯函数式编程是否与经典算法文献不兼容？

我想知道将算法封装到类中是多么(不)常见？更具体地说,不是使用许多单独的函数来转发彼此之间的公共参数:

void f(int common1, int param1, int *out1);
void g(int common1, int common2, int param1, int *out2)
{
  f(common1, param1, ..);
}

将公共参数封装到类中并完成构造函数中的所有工作:

struct Algo
{
  int common1;
  int common2;

  Algo(int common1, int common2, int param)
  { // do most of the work }

  void f(int param1, int *out1);
  void g(int param1, int *out2);
};

看起来非常实用,不必通过函数参数转发常见参数和中间结果.但我还没有看到这种"模式"被广泛使用..有什么可能的缺点？

在回答另一个问题时,我想到了以下示例:

void *p;
unsigned x = 17;

assert(sizeof(void*) >= sizeof(unsigned));
*(unsigned*)&p = 17;        // (1)
memcpy(&p, &x, sizeof(x));  // (2)

第1行打破了别名规则.然而,第2行是好的.别名规则.问题是:为什么？编译器是否具有关于memcpy等函数的特殊内置知识,还是有一些其他规则可以使memcpy正常运行？有没有办法在标准C中实现类似memcpy的函数而不破坏别名规则？

3参数形式list::splice()将单个元素从一个列表移动到另一个列表. SGI的文档明确声明所有迭代器,包括指向要移动的元素的迭代器仍然有效. Roguewave的文档没有说明splice()方法的迭代器失效属性,而C++标准明确声明它使所有迭代器和对被拼接元素的引用无效.

splicing()在实践中按照SGI的定义工作,但是我在微软的STL实现的调试/安全SCL版本中得到断言失败(解除引用无效迭代器)(严格遵循标准的字母).

现在,我正在使用list完全是因为我想在列表之间移动一个元素,同时保留指向它的迭代器的有效性.该标准对最初的SGI规范进行了极为无益的改变.

我该如何解决这个问题？或者我应该是务实,在沙把头(因为拼接并没有在实践中迭代器失效-甚至在MS的执行,一旦调试迭代器关闭).

我怎样才能做出类似这样的工作:

class Outer {
  int some_member;

  abstract class InnerBase {
    abstract void method();
  }
}

class OuterExtendsInner extends Outer.InnerBase {
  OuterExtendsInner(Outer o) { o.super(); }
  void method() {
    // How do I use some_member here?
    // Writing Outer.this.some_member -> error about Outer not being an enclosing class
    // Writing just some_member -> no-go, either
  }
}

解决方法是在InnerBase中有一个返回Outer.this并从派生类调用THAT的方法,但还有另一种方法吗？

我主要想从外部扩展InnerBase以获得更好的代码组织,但我可以将所有派生类移动到外部.

今天有很多人将单元测试作为发展的基础.这甚至可能适用于强大的面向算法的例程.但是,如何进行单元测试,例如内存分配器(想想malloc()/ realloc()/ free()).生成满足指定接口的工作(但绝对无用)的内存分配器并不难.但是如何提供绝对需要的单元测试功能的适当上下文,但不是合同的一部分:合并空闲块,在下一次分配时重用空闲块,将过多的空闲内存返回给系统,断言分配策略(例如第一次合适)真的受到尊重等

我的经验是断言,即使复杂和耗时(例如遍历整个空闲列表以检查不变量),工作要少得多,并且比单元测试更可靠,尤其是.编码复杂的,时间相关的算法.

有什么想法吗？

我想从一个文件中提取数据,该文件信息以big-endian存储,并且总是无符号的.从unsigned int到int的"强制转换"如何影响实际的十进制值？我是否纠正了最左边的位决定该值是正还是负？

我想用python解析该文件格式,并且读取和无符号值很容易:

def toU32(bits):
    return ord(bits[0]) << 24 | ord(bits[1]) << 16 | ord(bits[2]) << 8  | ord(bits[3])

但相应的toS32功能会如何？

感谢有关struct -module 的信息.但我仍然对我的实际问题的解决方案感兴趣.

当前的操作系统(windows,linux,BSD)是否提供驱动程序,使用户模式程序能够部分以可信执行模式执行(与计算机上运行的其他程序隔离)？如果是这样,哪里可以找到文件？

由于特定的要求[*],我需要一个单链表实现,它使用整数索引而不是链接节点的指针.索引始终根据包含列表节点的向量进行解释.

我想我可以通过定义自己的分配器来实现这一点,但是在查看gcc的实现时,它们明确地使用指针列表节点中的链接字段(即,它们不使用分配器提供的指针类型):

  struct _List_node_base
  {
    _List_node_base* _M_next;   ///< Self-explanatory
    _List_node_base* _M_prev;   ///< Self-explanatory
    ...
  }

(为此目的,分配器接口也缺点在于它没有定义解引用函数;"解除引用"整数索引总是需要指向底层存储的指针.)

您是否知道使用索引(wrt.基本向量)而不是链接节点指针的STL类数据结构库(我主要需要单链和双链表)？

[*]节省空间:列表将包含许多 32位整数.每个节点有两个指针(STL列表是双向链接的),64位平台上的开销是200%或400%,不包括默认分配器的开销.

编辑:我正在寻找以下列方式定义节点的SLL实现:

  struct list_node
  {
    int _value;  ///< The value in the list
    int _next;   ///< Next node in the list
    ...
  }

_next被解释为wrt.隐式数组或向量(必须在列表上运行的每个方法外部提供).

EDIT2:经过一番搜索后,我发现标准实际上要求与标准集合一起使用的分配器必须将指针类型定义为与T*等效.