小编aka*_*ppa的帖子

该标准提供了一个模板特化std::unique_ptr,正确调用delete[]其析构函数:

void func()
{
   std::unique_ptr< int[] > arr(new int[10]);

   .......
}

由于std::shared_ptr这种专业化不可用,因此有必要提供一个正确调用的删除器delete[]:

void func()
{
    // Usage
    shared_ptr array (new double [256], [](double* arr) { delete [] arr; } ); 

    ..............
}

这只是一个疏忽吗？(以同样的方式存在std::copy_if)或是否有原因？

我想用Java 计算任意数量的非空集的笛卡尔积.

我写过那个迭代代码......

public static <T> List<Set<T>> cartesianProduct(List<Set<T>> list) {
    List<Iterator<T>> iterators = new ArrayList<Iterator<T>>(list.size());
    List<T> elements = new ArrayList<T>(list.size());
    List<Set<T>> toRet = new ArrayList<Set<T>>();
    for (int i = 0; i < list.size(); i++) {
        iterators.add(list.get(i).iterator());
        elements.add(iterators.get(i).next());
    }
    for (int j = 1; j >= 0;) {
        toRet.add(Sets.newHashSet(elements));
        for (j = iterators.size()-1; j >= 0 && !iterators.get(j).hasNext(); j--) {
            iterators.set(j, list.get(j).iterator());
            elements.set(j, iterators.get(j).next());
        }
        elements.set(Math.abs(j), iterators.get(Math.abs(j)).next());
    }
    return toRet;
}

......但我发现它相当不优雅.有人有更好的,仍然是迭代的解决方案吗？使用一些奇妙的功能性方法的解决方案？否则......关于如何改进它的建议？错误？

我正在使用其他人编写的一些现有代码,我无法编译(这里有限的C经验,但我正在努力学习!).

utilities.cc

#include "utilities.h"
FILE *open_file(char *filename, const char*extension, const char *access)
{
  char string[MAX_STR_LEN];
  FILE *strm = NULL;

  if(filename[0]=='\0')
   {
      printf("\n INPUT FILENAME (%s) > ",access);
      fgets(string,MAX_STR_LEN,stdin);
      sscanf(string,"%s",filename);
      printf(" FILE %s opened \n", filename);
   }
   int len=strlen(filename);

   if( len + strlen(extension) >= MAX_STR_LEN)
   {
      printf("\n ERROR: String Length  of %s.%s Exceeds Maximum",
              filename, extension);
      return(NULL);
   } 

   // char *filename1 = new(char[len+strlen(extension)+1]);

   const int filenameLength = len+strlen(extension)+1;
   char *filename1 = new(char[filenameLength]);

   strcpy(filename1,filename); // temp filename for appending extension

   /* check …

理想情况下,我只需要一个简单的SSLSocketChannel.

我已经有一个组件可以读取和写入普通的消息SocketChannel,但对于其中一些连接,我必须通过线路使用SSL; 但是,这些连接上的操作是相同的.

有没有人知道一个免费的SSLSocketChannel实现(使用适当的选择器)或类似的东西？我发现了这个,但选择器不接受它,因为它的供应商不是SUN.

我正在通过一个简单的对象将read_from/writing_to网络逻辑与网络数据的插入和检索分离,以便使用SSLEngine而不会生气,但考虑到我不知道的事实,实现它是非常棘手的SSL协议的内部......

我需要在一堆关于内存层次结构效率的假设中评估C++函数所花费的时间(例如:当我们在读取数组的一部分时遇到缓存未命中,缓存命中或页面错误时所花费的时间),所以我我希望有一些库可以让我计算缓存未命中/页面错误,以便能够自动生成性能摘要.

我知道有一些像cachegrind这样的工具可以给出一些关于给定应用程序执行的相关统计信息,但我想要一个库,正如我已经说过的那样.

编辑哦,我忘了:我正在使用Linux,我对可移植性不感兴趣,这是学术性的东西.

欢迎任何建议!

我有一些编译问题在使用g ++ -std = c ++ 0x进行编译时将类型T的元素推回到向量.

这是一个最小的例子:

#include <vector>

using namespace std;

class A {
public:
    A() { }

    A& operator=(A &orig) {
        return *this;
    }
};

int main(int argc, char **argv) {
    A a;
    vector<A> b;
    A c = a; // This is fine
    b.push_back(a); // This is not, but only when compiling with -std=c++0x!
    return 0;
}

它使用g ++ -Wall -pedantic编译得很好,但是在使用g ++ -Wall -pedantic -std = c ++ 0x进行编译时会出现此错误:

 In file included from /usr/include/c++/4.4/vector:69,
                 from min.cpp:1:
/usr/include/c++/4.4/bits/vector.tcc: …

我需要设计一个框架来并行地计算除法和征服算法的结果.为了使用框架,用户需要以某种方式指定实现"划分"阶段(从T到T的函数),"征服"阶段(从D到D的函数)和T和D本身的过程.

我认为定义两个抽象类会很好,BaseDivide并且它会使用正确的类型BaseConquer声明一个纯虚方法compute:这样我就有了一个实现明确定义概念的类型(从框架的角度来看)通过派生抽象类包含用户可定义的函数.

我曾经想过使用模板将类型传递给框架,因此用户不必为了使用框架而实例化它们,所以像这样:

template <typename T, typename D, typename Divide, typename Conquer> 
D compute(T arg);

我的问题是我希望Divide and Conquer是派生类型BaseDivide和BaseConquer:有一种方法可以在编译时强制执行它吗？另外:你认为我可以通过更清洁的设计获得类似的结果吗？

为了好玩，我正在创建一个程序，为秘密圣诞老人礼物交换生成合作伙伴。但是，在此设置中，允许约束而不是随机生成对。

示例：A 和 B 彼此讨厌，因此不应指派 A 和 B 为对方购买礼物。

第二个例子：C 人去年为 D 人买了一件礼物。不应指派 C 为 D 购买礼物，但仍应允许 D 为 C 购买礼物。

一般来说，我想从集合到自身生成一个双射函数，但该函数需要对约束敏感。如果有太多的约束使得问题无法解决，则例程应该返回错误或其他内容。

在我看来，这就像某种图形问题，但我真的不知道要从哪个方向解决它。如何以编程方式解决此问题？是否有我可以使用/修改的现有算法？

好吧,我正在阅读FQA中关于将a转换Derived**为a Base**以及为什么禁止它的问题的这篇条目.我得到的问题是你可以分配给一个Base*不是a 的东西Derived*,所以我们禁止这样做.

到现在为止还挺好.

但是,如果我们深入应用这一原则,为什么我们不禁止这样的例子呢？

void nasty_function(Base *b)
{
  *b = Base(3); // Ouch!
}

int main(int argc, char **argv)
{
  Derived *d = new Derived;
  nasty_function(d); // Ooops, now *d points to a Base. What would happen now?
}

我同意nasty_function做一些愚蠢的事情,所以我们可以说让这种转换很好,因为我们启用了有趣的设计,但我们可以说也是为了双重间接:你有一个Base **,但你不应该给它任何东西尊重,因为你真的不知道它到底在哪里,Base **就像Base *.

所以,问题是:间接的额外级别有什么特别之处？也许重点是,只有一个间接层,我们可以使用虚拟operator=来避免这种情况,而普通指针上没有相同的机制吗？

这个示例代码应该编译吗？ clang并g++接受它,同时icc 14拒绝这样做,抱怨auto t = ...说std::unique_ptr复制构造函数未定义.

#include <iostream>
#include <memory>
#include <tuple>

std::tuple<std::unique_ptr<int[]>, int> foo()
{
    std::unique_ptr<int[]> a;
    unsigned int b;
    auto t = std::make_tuple(std::move(a), b); 
    return std::move(t);
}

int main()
{
    foo();
}

由于我对C++模板缺乏了解,我遇到了一个愚蠢的问题.

我有一个模板类Token和一个模板类Task.

任务在多图中包含一些令牌*; 我想迭代它们.

所以,在我的一个功能中,我写道:

template <typename C>
void Task<C>::f() {

    // some code...
    multimap<string, Token<C>* >::iterator it;

}

但我从g ++得到这个编译错误:

src/structures.cpp:29: error: expected ‘;’ before ‘it’

如果我把令牌或类似的东西,它编译.

哪里出错？

是否可以反编译C++ Builder exe？

C++ Builder是安全的编程工具还是任何人都可以反编译它并查看代码？