小编Esc*_*alo的帖子

我正在尝试在 C++ 中学习线程，并且只是有一些关于它的问题（更具体地说是<thread>.

假设运行此代码的机器有 4 个内核，我应该将一个操作拆分为 4 个线程吗？如果我要创建 8 个线程而不是 4 个线程，这会在 4 核机器上运行得更慢吗？如果处理器具有超线程，我应该尝试使线程与物理内核或逻辑内核的数量相匹配吗？

我应该不担心机器拥有的核心数量，并尝试创建尽可能多的线程吗？

如果这些问题已经得到解答，我深表歉意；我一直在寻找有关线程 with 的信息<thread>，它是在 c11 中引入的，所以我找不到太多关于它的信息。

有问题的程序将运行许多独立的模拟。

如果有人对<thread>多线程有任何见解或只是一般的多线程，我会很高兴听到它。

我正在比较Fortran 90和C++进行演示.我的一个比较依赖于通过简单的程序产生的装配g++和gfortran.

一个例子如下:

#include<cstdio> // quick and dirty number formatting

template<int N>
double dot(double x[], double y[]){
  return x[N-1] * y[N-1] + dot<N-1>(x, y);
}

template<>
double dot<1>(double x[], double y[]){
  return x[0] * y[0];
}

int main(){
  double x[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  double y[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  printf("x.y = %23.16E\n", dot<10>(x, y));
}

g++ -S -O3 myprogram.cpp在OS X …

如果我有课,比方说,

class Car {
  public:
    void Drive();
    void DisplayMileage() const;
};

我基于这个类创建了一个共享指针,

typedef boost::shared_ptr<Car> CarPtr;

然后我继续填充CarPtrs的载体,

std::vector<CarPtrs> cars...;

我现在想迭代向量并做一些事情:

for(auto const &car : cars) {
   car->DisplayMileage(); // I want this to be okay
   car->Drive(); // I want the compilation to fail here because Drive isn't const.
}

这是否可以在不将汽车的共享指针转换为指向const汽车的共享指针的情况下实现？

想象一个系统(Python),其中不同的部分不断地与给定对象的一个​​实例交互.为此实例提供全局访问点的最佳方法是什么？

到目前为止,我只能想到建设中的(辛格尔顿)实例__init__.py和import模块的需要:

# __init__.py
class Thing(object, Singleton):
 pass

TheThing = Thing()

__all__ = ['TheThing']  

有没有更好的方法来提供全局访问点TheThing？

谢谢,

J.

一个脚本用于在团队之间交换文件信息.它用作:

$ share.py -p /path/to/file.txt

参数检查确保/path/to/file.txt存在并具有正确的权限:

#[...]
# ensure that file exists and is readable
if not os.access(options.path, os.F_OK):
 raise MyError('the file does not exist')
# ensure that path is absolute
if not os.path.isabs(options.path):
 raise MyError('I need absolute path')
# ensure that file has read permissions for others
info = os.stat(options.path)
last_bit = oct(info.st_mode)[-1]
if not last_bit in ['4', '5', '6', '7']:
 raise MyError('others cannot read the file: change permission')

问题是一个用户发送了:

$ share.py -p/path/to /

并且程序没有像它应该的那样失败.在回顾展中我应该看到这一点,但我没有.

如何添加测试以确保路径是常规文件,可能有也可能没有扩展名(我不能简单地处理名称字符串 …

以下程序可以成功运行:

class Simple(object):
    def __init__(self, name):
      self.name = name

    def __add__(self, other):
      c = Composite()
      c._members.append(self)
      c._members.append(other)
      return c

    def __repr__(self):
      return "Simple('%s')" % self.name

class Composite(object):
    def __init__(self):
      self._members = []

    def __add__(self, obj):
      if isinstance(obj, Simple):
        out = Composite()
        out._members = [k for k in self._members] + [obj]
      elif isinstance(obj, Composite):
        out = Composite()
        out._members = [k for k in self._members + obj._members]
      else:
        raise TypeError
      return out

if __name__ == "__main__":
    s1 = Simple('one')
    s2 = Simple('two') …

我正在使用一个加载库的遗留Perl应用程序,称之为"blah".我需要知道"blah"在我的文件系统中的位置.

我对Perl一点也不熟悉,我想知道__file__在Python 中使用特殊变量的行来打印模块路径的等效方法是什么.换句话说,Perl相当于以下Python脚本:

import blah
print blah.__file__

非常感谢.

我想创建一个简单的辅助算法来填充容器,例如std::vector<T>,具有几何级数(第一个术语是a,n第 - 个术语由给定的比率给出a * pow(r, n-1),其中r是给定的比率); 我创建了以下代码:

#include<vector>
#include<algorithm>
#include<iostream>

template<template <typename> class Container, typename T>
void progression(Container<T>& container, T a, T ratio, size_t N) {
  if(N > 0) {    
    T factor = T(1);  
    for(size_t k=0; k<N; k++) {
      container.push_back(a * factor);
      factor *= ratio;
    }
  }
}

int main() {
  std::vector<double> r;
  progression(r, 10.0, 0.8, static_cast<size_t>(10));

  for(auto item : r) {
    std::cout<<item<<std::endl;
  }

  return 0;
}

尝试编译时产生以下错误:

$ g++ …