小编Fra*_*ank的帖子

我有一个std::set<Foo>,我想更新其中现有元素的一些值.请注意,我正在更新的值不会更改集合中的顺序:

#include <iostream>
#include <set>
#include <utility>

struct Foo {
  Foo(int i, int j) : id(i), val(j) {}
  int id;
  int val;
  bool operator<(const Foo& other) const {
    return id < other.id;
  }
};

typedef std::set<Foo> Set;

void update(Set& s, Foo f) {
  std::pair<Set::iterator, bool> p = s.insert(f);
  bool alreadyThere = p.second;
  if (alreadyThere)
    p.first->val += f.val; // error: assignment of data-member
                           // ‘Foo::val’ in read-only structure
}

int main(int argc, char** argv){
  Set s;
  update(s, Foo(1, 10)); …

我想在Perl中读取UTF-8输入,无论它来自标准输入还是来自文件,使用菱形运算符:while(<>){...}.

所以我的脚本应该像往常一样以这两种方式调用,给出相同的输出:

./script.pl utf8.txt
cat utf8.txt | ./script.pl

但产出不同!只有第二次调用(使用cat)似乎按设计工作,正确读取UTF-8.这是脚本:

#!/usr/bin/perl -w

binmode STDIN, ':utf8';
binmode STDOUT, ':utf8';

while(<>){
    my @chars = split //, $_;
    print "$_\n" foreach(@chars);
}

在两种情况下如何才能正确读取UTF-8？<>如果可能的话,我想继续使用钻石操作员进行阅读.

编辑:

我意识到我应该描述不同的输出.我的输入文件包含以下序列:a\xCA\xA7b.cat正确输出的方法:

a
\xCA\xA7
b

但另一种方法给了我这个:

a
\xC3\x8A
\xC2\xA7
b

我有一个处理给定向量的函数,但如果没有给出,也可以自己创建这样的向量.

我看到这种情况有两种设计选择,其中一个函数参数是可选的:

将它设为指针并NULL默认设置为:

void foo(int i, std::vector<int>* optional = NULL) {
  if(optional == NULL){
    optional = new std::vector<int>();
    // fill vector with data
  }
  // process vector
}

或者有两个带有重载名称的函数,其中一个省略了参数:

void foo(int i) {
   std::vector<int> vec;
   // fill vec with data
   foo(i, vec);
}

void foo(int i, const std::vector<int>& optional) {
  // process vector
}

是否有理由选择一种解决方案而不是另一种？

我稍微偏爱第二个,因为我可以将向量作为const引用,因为它在提供时只能读取而不能写入.此外,界面看起来更干净(NULL不仅仅是一个黑客？).并且间接函数调用产生的性能差异可能会被优化掉.

然而,我经常在代码中看到第一个解决方案.除了程序员的懒惰之外,是否有令人信服的理由更喜欢它？

我可以使用迭代器进行正常计算,即只需通过添加数字来增加它吗？

例如,如果我想删除元素vec[3],我可以这样做:

std::vector<int> vec;
for(int i = 0; i < 5; ++i){
      vec.push_back(i);
}
vec.erase(vec.begin() + 3); // removes vec[3] element

它适用于我(g ++),但我不确定它是否可以保证工作.

如果我想使类适应,并且可以从外部选择不同的算法 - C++中最好的实现是什么？

我主要看到两种可能性:

• 使用抽象基类并传递具体对象
• 使用模板

这是一个小例子,在各种版本中实现:

版本1:抽象基类

class Brake {
public: virtual void stopCar() = 0;  
};

class BrakeWithABS : public Brake {
public: void stopCar() { ... }
};

class Car {
  Brake* _brake;
public:
  Car(Brake* brake) : _brake(brake) { brake->stopCar(); }
};

版本2a:模板

template<class Brake>
class Car {
  Brake brake;
public:
  Car(){ brake.stopCar(); }
};

版本2b:模板和私有继承

template<class Brake>
class Car : private Brake {
  using Brake::stopCar;
public:
  Car(){ stopCar(); }
};

来自Java,我自然倾向于始终使用版本1,但模板版本似乎经常是首选,例如在STL代码中？如果这是真的,是因为内存效率等(没有继承,没有虚函数调用)？

我意识到版本2a和2b之间没有太大的区别,请参阅C++ …

好的,mkstemp是在POSIX中创建临时文件的首选方法.

但它会打开文件并返回一个int文件描述符.从那以后我只能创建一个FILE*,而不是一个std::ofstream,我更喜欢C++.(显然,在AIX和其他一些系统上,您可以std::ofstream从文件描述符创建一个,但是当我尝试时,我的编译器会抱怨.)

我知道我可以获得一个临时文件名,tmpnam然后用它打开我自己的ofstream,但由于竞争条件,这显然是不安全的,并导致编译器警告(Linux上的g ++ v3.4.):

warning: the use of `tmpnam' is dangerous, better use `mkstemp'

那么,是否有任何可移植的方法来创建std::ofstream临时文件？

编程有哪些好的做法R？

由于R我不是一直使用的特殊用途语言,我通常只是将一些快速脚本组合在一起,以满足我的需求.

但是编写干净,高效的R代码有哪些技巧？

我有一些特殊的异常情况,我想抛出并捕获,所以我想定义自己的异常类.

有什么最好的做法？我应该继承std::exception还是std::runtime_error？

我经常使用const未修改的局部变量,如下所示:

const float height = person.getHeight();

我认为它可以使编译后的代码更快,允许编译器进行更多优化.或者我错了,编译器可以自己弄清楚局部变量永远不会被修改？

Go的多线程方法和其他方法有什么区别,比如pthread,boost :: thread或Java Threads？