小编Mat*_*ric的帖子

最近，我有以下情况

struct data {
  std::vector<int> V;
};

data get_vector(int n)
{
  std::vector<int> V(n,0);
  return {V};
}

这段代码的问题在于，在创建结构体时会发生一个副本，而解决方案是编写return {std::move(V)}

是否有可以检测这种虚假复制操作的 linter 或代码分析器？cppcheck、cpplint 和 clang-tidy 都做不到。

编辑：几点让我的问题更清楚：

1. 我知道发生复制操作是因为我使用了编译器资源管理器，它显示了对memcpy的调用。
2. 我可以通过查看标准 yes 来确定发生了复制操作。但我最初的错误想法是编译器会优化掉这个副本。我错了。
3. 这（很可能）不是编译器问题，因为 clang 和 gcc 都产生产生memcpy 的代码。
4. memcpy 可能很便宜，但我无法想象复制内存和删除原始内存比通过std::move传递指针便宜的情况。
5. 添加std::move是一个基本操作。我想代码分析器将能够建议此更正。

假设我有以下代码

    IF (a.eq.0.or.M(a)) THEN

使用整数和M(1:3)逻辑数组.如果a等于0,那么我希望第一个测试能够捕获它而第二个测试永远不会被评估.但是,如果我使用intel fortran编译器并编译

    -check all

然后我遇到了分段错误.没有此调试选项,不会发生错误.这是标准行为吗？对于许多语言,在手册中明确说明了

    IF (A.or.B) THEN

如果A为真,则不评估B. Fortran标准是否明确要求即使不影响最终结果也可以评估A和B？

我构建了一个包含没有默认构造函数的向量的类.特别:

template<typename T>
struct MyVector
{
public:
  int GetN(void)
  {
    return n;
  }
  MyVector(int n1)
  {
    n=n1;
    ListElt = new T[n1];
  }
  ~MyVector()
  {
    delete [] ListElt;
  }
  // some other irrelevant to the question code
private:
  int n;
  T *ListElt;
};

现在我想构建一个派生自它的类,它包含一个整数和一个向量.有效的代码如下:

struct EquivInfo {
public:
  EquivInfo(int inpOrbit, MyVector<int> &inpMat)
  {
    iOrbit=inpOrbit;
    eVect=new MyVector<int>(inpMat.getN());
    // some code for copying the vector in place.
  }
  ~EquivInfo()
  {
    delete eVect;
  }
private:
  int iOrbit;
  MyVector<int> *eVect;
};

有没有办法避免使用向量的指针？

问题是如果我删除指针然后调用MyVector()类型的构造函数.我不懂为什么.应该有一种方法可以让EquivInfo的构造函数为MyVector调用一个精确的构造 …

我想运行一系列流，其中多个流进程同时运行。我尝试的测试代码如下：

use tokio;
use tokio_stream::{self as stream, StreamExt};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let stream = stream::iter(0..10)
        .then(|i| async move {
            tokio::time::sleep(Duration::from_secs(1)).await;
            println!("i={:?}", i);
        })
        .chunks_timeout(3, Duration::from_secs(20));

    let _result : Vec<_> = stream
        .collect().await;
}

此代码运行，但它会一一打印 10 个值，并有 1 秒的延迟。这与并发相反。我期望的是等待 3 秒，打印 3 个数字，然后等待 1 秒，依此类推。我认为这tokio::time::sleep很好，因为join_all我让代码同时工作。

那么，如何解释缺乏并发性以及如何解决呢？