让我先说一下,我已经阅读了一些有关移动语义的问题.这个问题不是关于如何使用移动语义,而是询问它的目的是什么 - 如果我没有弄错,我不明白为什么需要移动语义.

背景

我正在实施一个沉重的类,为了这个问题的目的,它看起来像这样:

class B;

class A
{
private:
    std::array<B, 1000> b;
public:
    // ...
}

在制作移动赋值运算符的时候,我意识到我可以通过将b成员更改为std::array<B, 1000> *b;- 来进行显着优化- 然后移动可能只是删除和指针交换.

这引出了以下想法:现在,不应该所有非原始类型的成员都指向加速移动(在[1] [2]下面更正)(有一种情况应该是内存不应该是动态分配,但在这些情况下,优化运动不是问题,因为没有办法这样做)？

这里是我有以下实现的地方 - 为什么创建一个A真正只包含指针的类,b因此当我可以简单地创建指向整个A类本身的指针时,以后交换更容易.显然,如果客户端期望移动速度明显快于复制速度,则客户端应该可以使用动态内存分配.但在这种情况下,为什么客户端不仅动态分配整个A类？

问题

客户端是否已经利用指针来完成移动语义给我们的一切？如果是这样,那么移动语义的目的是什么？

移动语义:

std::string f()
{
    std::string s("some long string");
    return s;
}

int main()
{
    // super-fast pointer swap!
    std::string a = f();
    return 0;
}

指针:

std::string *f()
{
    std::string *s = new std::string("some long string"); …

在多处理器编程的艺术中,rev.第1版,在Ch.2,练习9如下(转述):

限定R-界定等待互斥算法意味着d _甲^Ĵ ➝d _乙^ķ ⇒CS _甲^Ĵ ➝CS _乙^{ķ+ R}.有没有办法为Peterson算法定义一个门口,以便提供r-bounded等待？

本书使用➝来定义事件优先顺序的总顺序,其中X➝Y表示事件X在Y开始之前开始并完成.D _A是线程A的"门口"事件,它是请求进入关键部分的事件.CS _A是线程A的关键部分事件.

对于任何事件X _A,X _A ⁱ是线程A上事件X的第i次执行.

现在回答这个问题:在我看来,Peterson算法是完全公平的(0-有限等待).此外,我认为r-bounded等待意味着k-bounded等待所有k> r.然后这个问题没有意义,因为彼得森应该满足r-bounded等待所有r.

问题是要求Peterson算法的"简化",因为它要求放宽约束？

这是自学,而不是作业.

Peterson锁算法的代码取自本书:

1 class Peterson implements Lock {
2     // thread-local index, 0 or 1
3     private volatile boolean[] flag = new boolean[2];
4     private volatile int victim;
5     public void lock() {
6         int i = ThreadID.get();
7         int j = 1 - i;
8         flag[i] = true; …

在阅读了这个问题并在此处查看了一些结果后,似乎应该完全避免使用C++中的列表.我总是期望链接列表是我只需要迭代所有内容的情况下的首选容器,因为插入是指针操作的问题,并且永远不需要重新分配.

显然,由于"缓存局部性",列表的迭代速度非常慢,因此必须使用更少的保留内存或更快的添加(从第二个链接看起来速度不是那么快)的任何好处似乎都不值得它.

话虽如此,当我应该,从性能的角度来看,使用std::list过std::deque或者,如果可能的话,std::vector？

另外,std::forward_list还会有很多缓存未命中？

我正在使用cabal帮助组织我的依赖项,构建进程,并测试我正在进行的一个小型Haskell项目.当前的cabal文件包含如下行:

library
  hs-source-dirs:      src
  exposed-modules:     Project.Exposed1
                       , Project.Exposed2
                         -- pretty please don't use below modules
                       , TestingUtilityFunctions
                       , GenericUtilityFunctions

  other-modules:       Convenient submodule for responsibility separation
                       , Another one

executable E1
  -- relies on Project for both Project.Exposed1 AND GenericUtilityFunctions

testsuite T2
  -- relies on Project for both Project.Exposed2 AND TestingUtilityFunctions

我需要保持TestingUtilityFunctions和GenericUtilityFunctions暴露,因为它们出现在E1和T2.但是,它们不应该出现在库中,因为库的功能不是提供通用的实用程序功能(我根据需要改变),而是提供Project.Exposed*模块公开的接口.

有没有办法建立一个"私有"库(或几个,以最大限度地减少依赖性过度包含),我可以在我的包中使用,但跨越可执行文件和测试套件？

是否可以从调用的程序本身修补python程序的copy-and-pastable调用？它不必是完全相同的调用字符串,但参数应该解析为同一个东西.

请注意' '.join(sys.argv),不幸的是,它不会削减它.我对这种方法的主要问题是它不能正确引用参数.考虑dummy.py与import sys; print(sys.argv); print(' '.join(sys.argv))

运行python dummy.py "1 2"打印:

['dummy.py', '1 2']
dummy.py 1 2

当然,如果我们复制后者,我们将获得不同的调用.用引号括起每个参数也不起作用.考虑dummy2.py:

import sys
print(sys.argv)
print(' '.join('"{}"'.format(s) for s in sys.argv))

这将打破:

python dummy2.py ' " breaking " '

Java允许类显示Iterable类型,以便客户端可以遍历某个实例的数据集合,如下所示:

public class MyClass
{
    private ArrayList<String> strings;
    private ArrayList<Integers> ints;
    public MyClass() { /* generate data ... */ }
    public Iterable<String> allStrings() {return strings;}
    public Iterable<Integer> allInts() {return ints;}
}

这总是让我感到"干净",因为它保持了封装,允许我在需要ArrayList的时候将LinkedLists 更改为s ,并且在构造中仍然方便客户端for(String s : myClassInstance.allStrings()) //....

但是,在C++中,如果我想允许客户端使用我的for-loop,在没有的情况下Iterable,我需要返回一个const vector<T>&或者其他什么,这显然不是太大.

定义template<> begin<my_class> {/*...*/}和朋友很好,但只有my_class有一个集合来迭代.我还可以做些什么？

该std::vector班有一个方便的构造函数允许其参数的任何输入迭代器.我想在我自己的类中实现一个类似的模式,因为类在实例化时需要接受一些集合,但是我想在集合上使用迭代器来进行封装.我想到的一种方法是使用输入迭代器类型对整个类进行模板化,但这不是STL所做的,因为vector显然只是模拟迭代的类型.当然,一个选项是模板生成器函数,但我真的想知道它是如何通过实现STL的编译器完成的 - 不知何故,InputIterator类型是仅特定于构造函数的类型名,即使构造函数不能被模板化.

(是的,我试过看,vector.tpp但我无法理解).

金融和强化学习中的常用术语是C[i]基于原始奖励的时间序列的折扣累积奖励R[i].给定一个数组R,我们想用(并返回完整的数组)计算C[i]满足重现.C[i] = R[i] + discount * C[i+1]C[-1] = R[-1]C

在numpy数组的python中计算这个数值稳定的方法可能是:

import numpy as np
def cumulative_discount(rewards, discount):
    future_cumulative_reward = 0
    assert np.issubdtype(rewards.dtype, np.floating), rewards.dtype
    cumulative_rewards = np.empty_like(rewards)
    for i in range(len(rewards) - 1, -1, -1):
        cumulative_rewards[i] = rewards[i] + discount * future_cumulative_reward
        future_cumulative_reward = cumulative_rewards[i]
    return cumulative_rewards

但是,这依赖于python循环.鉴于这是一个如此常见的计算,当然有一个现有的矢量化解决方案依赖于其他一些标准函数而不需要求助于cythonization.

请注意,使用类似内容的任何解决方案np.power(discount, np.arange(len(rewards))都不会很稳定.