Fatal编程技术网

C++ 如何在C++；？

c++ vector

C++ 如何在C++；？,c++,vector,C++,Vector,我想用一个标量乘以一个向量。该向量是使用我的答案创建的，即： std::vector<int> n(N + 1); std::iota(begin(n), end(n), 0); < >我的C++程序。这返回了编译错误： error: ‘T’ was not declared in this scope std::bind1st(std::multiplies<T>(),pin)); 您需要用向量中包含的类型替换T，在本例中为int

我想用一个标量乘以一个向量。该向量是使用我的答案创建的，即：

std::vector<int> n(N + 1);
  std::iota(begin(n), end(n), 0);
< >我的C++程序。这返回了编译错误：

error: ‘T’ was not declared in this scope
                std::bind1st(std::multiplies<T>(),pin));
您需要用向量中包含的类型替换
T
，在本例中为
int
。但是，您可以在此处使用lambda函数来简化代码：

#include <algorithm> // for std::transform
#include <cmath>     // for M_PI
#include <iostream>  // for std::cout etc
#include <numeric>   // for std::iota
#include <vector>    // for awesome

int main() {
  std::vector<int> vec1(10);
  std::iota(vec1.begin(), vec1.end(), 0);

  int N = 42;

  std::vector<double> vec2(vec1.size()); // vec2 needs to be as big or bigger than vec1

  std::transform(vec1.begin(), vec1.end(), vec2.begin(),
                 [N](int i) { return i * M_PI / N; });

  for (auto a : vec1)
    std::cout << a << " ";
  std::cout << std::endl;

  for (auto a : vec2)
    std::cout << a << " ";
  std::cout << std::endl;
}

#include
您需要用向量中包含的类型替换
T
，在本例中为
int
。但是，您可以在此处使用lambda函数来简化代码：


#include <algorithm> // for std::transform
#include <cmath>     // for M_PI
#include <iostream>  // for std::cout etc
#include <numeric>   // for std::iota
#include <vector>    // for awesome

int main() {
  std::vector<int> vec1(10);
  std::iota(vec1.begin(), vec1.end(), 0);

  int N = 42;

  std::vector<double> vec2(vec1.size()); // vec2 needs to be as big or bigger than vec1

  std::transform(vec1.begin(), vec1.end(), vec2.begin(),
                 [N](int i) { return i * M_PI / N; });

  for (auto a : vec1)
    std::cout << a << " ";
  std::cout << std::endl;

  for (auto a : vec2)
    std::cout << a << " ";
  std::cout << std::endl;
}



#包括
如果我正确理解了您，您需要以下内容


std::vector<double> v;
v.reserve(n.size());

std::transform(n.begin(), n.end(), std::back_inserter( v ),
    std::bind1st(std::multiplies<double>(), pin));



std:：vector v；
v、 储备（n.size（））；
std:：transform（n.begin（）、n.end（）、std:：back_插入器（v），
std:：bind1st（std:：multiplies（），pin））；

如果我理解正确，您需要以下信息


std::vector<double> v;
v.reserve(n.size());

std::transform(n.begin(), n.end(), std::back_inserter( v ),
    std::bind1st(std::multiplies<double>(), pin));



std:：vector v；
v、 储备（n.size（））；
std:：transform（n.begin（）、n.end（）、std:：back_插入器（v），
std:：bind1st（std:：multiplies（），pin））；

对于
向量
输出，一种方法是：


auto npi = n;

for( auto& i: npi )
    i *= pin;


如果
npi
应为
vector
（问题不清楚），则将第一行替换为：


std::vector<double> npi( n.begin(), n.end() );


向量npi（n.begin（），n.end（））；

对于
向量
输出，一种方法是：


auto npi = n;

for( auto& i: npi )
    i *= pin;


如果
npi
应为
vector
（问题不清楚），则将第一行替换为：


std::vector<double> npi( n.begin(), n.end() );


向量npi（n.begin（），n.end（））；
您可以在Lambda函数的capture子句中传递标量，并在Lambda函数内部执行乘法

    #include <algorithm>
    #include <vector>
    
    std::vector<int> foo; 
    std::vector<int> bar;
    auto npi=4.0;
    std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), [&npi](auto& c){return c * npi;}

#包括
#包括
std：：矢量foo；
向量条；
自动净现值=4.0；
std:：transform（foo.begin（），foo.end（），bar.begin（），foo.begin（），[&npi]（自动&c）{return c*npi；}
您可以在Lambda函数的capture子句中传递标量，并在Lambda函数内部执行乘法

    #include <algorithm>
    #include <vector>
    
    std::vector<int> foo; 
    std::vector<int> bar;
    auto npi=4.0;
    std::transform (foo.begin(), foo.end(), bar.begin(), foo.begin(), [&npi](auto& c){return c * npi;}

#包括
#包括
std：：矢量foo；
向量条；
自动净现值=4.0；
std:：transform（foo.begin（），foo.end（），bar.begin（），foo.begin（），[&npi]（自动&c）{return c*npi；}
这会将结果存储为
n
（从而覆盖我的
n
向量）？是的，这将是。可能有一种方法可以将
std:：transform
的输出写入一个新的向量，但是…准备…值得注意的是
pin
不是整数吗？它是
pi/N
其中N是整数。这不意味着应该使用
double
类型吗？没问题-我已经扩展了这个例子。你知道吗可能不需要使用
std:：bind1st（std:：multiplies
。这会将结果存储为
n
（从而覆盖我的
n
向量）？是的，这将是。可能有一种方法可以将
std:：transform
的输出写入一个新的向量，但是…准备…值得注意的是
pin
不是整数吗？它是
pi/N
其中N是整数。这不意味着应该使用
double
类型吗？没问题-我已经扩展了这个例子。你知道吗但可能不需要使用
std:：bind1st（std:：multiples
。您的向量是int。如果将它乘以双标量，向量中的值仍然是int-目标向量需要是双精度的，因此如果要就地修改，请将向量更改为向量
double（N）
是C风格的强制转换。强制转换最好尽可能避免（这里不需要，因为N已经是双精度的）。如果需要，最好使用C++-style
static\u强制转换（N）
。我认为
begin（foo）
和
foo.begin（）
总是等价的（尽管不确定），在这种情况下，最好始终坚持一种风格。这是一个非常次要的观点，可能过于迂腐，但一致性使代码更清晰！
N
已经是双精度的，因此不需要演员阵容。请澄清什么是
npi
应该是--
vector
，
vector
，或者其他什么？您现有的代码es以就地修改
n
（因此给出
vector
输出）。您的向量为int。如果将其乘以双标量，向量中的值仍将为int-目标向量需要为双倍，因此如果要就地修改，请将向量更改为vector
double（n）
是C风格的强制转换。强制转换最好尽可能避免（这里不需要，因为N已经是双精度的）。如果需要，最好使用C++-style
static\u强制转换（N）
。我认为
begin（foo）
和
foo.begin（）
总是等价的（尽管不确定），在这种情况下，最好始终坚持一种风格。这是一个非常次要的观点，可能过于迂腐，但一致性使代码更清晰！
N
已经是双精度的，因此不需要演员阵容。请澄清什么是
npi
应该是--
vector
，
vector
，或者其他什么？您现有的代码es修改
n
到位（因此给出
向量
输出）。如果OP想要一个
向量
，但OP想要一个
向量
作为输出，那就行了。否则，这是非常令人愉快的简洁！@JackDeeth OP没有说他想要一个
向量
输出。而他的原始代码试图进行适当的转换，表明他想要的是
向量
输出；al尽管他在评论中说他不想覆盖原始向量。@我没有想到
int a=int b*double c
可能是一件有用的事情。打得好！@JackDeeth你可能是对的，但我可以想象一些整数结果的应用程序（例如，在晶格上而不是在连续空间上工作）如果OP想要一个
向量
，但是OP想要一个
向量
作为输出，那么这就行了。否则，这是非常困难的