小编And*_*s T的帖子

我写了一个非常小的程序:

#include <array>
#include <tuple>
#include <iostream>

const unsigned int NUM = 500;

void simple()
{
    using namespace std;
    array<tuple<float, float, float>, NUM> vectors;
}

int main(int argc, char **argv) 
{
    std::cout << "Hello, world!" << std::endl;
    return 0;
}

我编译了它g++ -std=c++0x.

这个版本工作正常,但如果我增加到NUM50,000,000,g ++使用90%的CPU,我的系统完全冻结.

我知道如果没有足够的堆栈内存,程序可能会在执行期间崩溃.但是为什么编译器会在编译期间冻结？

这是g ++中的错误还是由于某种原因编译器需要在编译期间分配堆栈内存？

C++标准库提供了将Comparator传递给std::sort.但是,在我的代码中我有很多情况需要T通过函数对对象列表进行排序f.像这样的比较器将是一个有效的选项:

bool compare(const T& a, const T& b) {
  return f(a) < f(b);
}

这不是最佳选择.f评估速度很慢,但每次使用同一个T对象的调用都会返回相同的值.所以我宁愿做的是f为范围内的每个对象计算一次,然后使用这些结果对它们进行排序.

我的目标是编写这个函数(我无法做到):

template <typename IterT, typename Transformation>
void sort(IterT left, IterT right, Transformation f) { /* ? */ }

这样,这个电话之后,f(*iter) <= f(*std::next(iter))所有iter序列中left来right.

此外,该功能应满足这些要求:

• 不分配任何其他类型的对象T.
• 评估f正是std::distance(left, right)很多次.
• 保持O(n log n)的整体复杂性.
• 应该用std :: sort来实现.当然,我可以通过实现自己的合并排序来解决这个问题,但这是我想避免的.

(C++ 11是首选; C++ 14也可以)

我正在寻找一种算法来解决以下问题:我们给出了一个大小为n的整数数组,其中包含k(0 <k <n)个元素恰好一次.每个其他整数在数组中出现偶数次.输出应该是k个唯一数字中的任何一个.k是固定数字,不是输入的一部分.

一个例子是输入[1, 2, 2, 4, 4, 2, 2, 3],1和3都是正确的输出.

最重要的是,算法应该在O(n)时间内运行,并且只需要额外的O(1)空间.

编辑:关于是否只有一个唯一的整数或多个,存在一些混淆.我为此道歉.正确的问题是存在任意但固定的数量.我已经更新了上面的原始问题.

"但丁".对于最多有两个这样的数字的情况给出了一个很好的答案.此链接还提供三种解决方案."David Eisenstat"评论说,任何固定的k都可以做到.我很感激解决方案.

我试图从C中的C++标准库重新创建一些类.例如,std :: pair类.
为了模拟模板,我当然使用了宏.以下是它的外观示例:

#define _TEMPLATE_PAIR_STRUCT(T1, T2, TNAME, STRNAME) \
typedef struct {                                  \
    T1* first;                                    \
    T2* second;                                   \
} STRNAME;

#define _TEMPLATE_PAIR_NEW(T1, T2, TNAME, STRNAME) \
    STRNAME* TNAME##_new()                         \
    {                                              \
        STRNAME *new = malloc(sizeof( STRNAME ));  \
        new->first = malloc(sizeof(T1));           \
        new->second = malloc(sizeof(T2));          \
        return new;                                \
    }

如果我试图在多个源文件中使用此结构,我必须多次生成代码.显然,这会导致错误.

有没有办法解决这个问题,所以我可以在C中使用这些"模板"？

在C++ 11中,提供两个版本方法的最佳方法是什么,一个用于修改对象本身,另一个用于返回修改后的副本？

例如,考虑一个具有"append(string)"方法的字符串类.有时您可能希望使用append来修改现有的字符串对象,有时您可能希望保持字符串对象相同并创建副本.

当然,我可以实现第一个版本并在每次需要时手动创建一个新对象,但这会为我的项目添加多个临时变量和代码行.

如果还不清楚我想做什么:

String s1("xy");
String s2 = s1.appendCopy("z");
s1.appendThis("w");
// s1 == "xyw"
// s2 == "xyz"

在Ruby中有一个概念(或者更确切地说,命名约定),对于这样的方法,有两种变体:append(创建一个新的String)并追加!(修改此对象)

C++没有这样的东西,所以我会陷入丑陋的方法名称,如"appendCopy".

有没有一种好方法来实现我想要做的事情？

到目前为止,我最好的想法是使修改版本的类成员和复制/不可变版本的静态方法使对象作为const参数工作.

我目前有以下形式的代码:

Do1(A);
if (B != null) Do1(B);

Do2(A, true);
if (B != null) Do2(B, true);

Do3(A);
if (B != null) Do3(B);

所以好几次,我为对象A执行了一些操作,如果指定了B,我也会为B执行此操作.这意味着我的整个代码都是重复的,我想改变它但我无法想出一个好方法改善这种模式.

到目前为止,我唯一的想法是

auto doBoth = [&A,&B](function<void(const T&)> f) {
  f(A);
  if (B != null) f(B);
};

doBoth(&Do1);
auto do2_bind = [](const T& obj) {Do2(obj, true);};
doBoth(do2_bind);
doBoth(&Do3);

但我觉得这会大大降低可读性,让人更难理解我的代码,因为有一个非常抽象的lambda函数和一般的很多lambdas.

编辑:从答案和评论我看到我应该做出一些澄清.我为混乱道歉.

1. A和B属于同一类型,类似于Foo*或可选的<Foo>,它允许测试null

2. 我只能使用C++ 11功能

3. 代码块(我在这里简称为DoN)可能比单个函数调用更复杂.例如,如果可能是:

   Do1(A);
   Do2(A);
   if (B != null) {
     Do1(B);
     Do2(B);
   }
   

   Run Code Online (Sandbox Code Playgroud)

操作顺序很重要.