Question

vector<double> function(vector<double> &X){
    vector<double> data2;
    for (int i = 0; i < X.size(); i++){
        data2.push_back(2*X[i]);
    }
    return data2;
}
int main(){
    vector<double> data;
    for (int i = 1; i <= 10; i++){
        data.push_back(i);
    }
    for (int i = 0; i < data.size(); i++){
        cout << function(data) << endl;
    }
return 0;
}

基本上，对于数据[i] = i的给定人工创建的“数据”向量，我想要一个函数，使它将向量的每个元素乘以2，然后打印结果。但是，我似乎无法理解我做错了什么。

Answer 1

function会返回std::vector这是一种容器。我们无法使用std::cout打印std::vector的元素我们应该进入容器来获取元素并打印出来像这样：

data2 = function(data);
for (int i = 0; i < data2.size(); i++)
{
        cout << data2[i]<< endl;
}

Answer 2

首先，为了简化操作，让我们编写一个打印出矢量内容的简单函数。现在，要查看矢量的外观，我们可以调用该函数并查看其外观。

template <typename T>
void printVector(const vector<T> &input){
    unsigned sz = input.size();
    cout<<"========"<<endl;
    for(unsigned i=0; i<sz; i++){
        cout<<input[i]<<endl;
    }
    cout<<"========"<<endl;
}

请记住，如果函数接受泛型类的对象（例如std :: vector＆lt; T＆gt;），则需要指定它是模板函数。

现在，回到你的问题。我假设您不希望更改data本身的值，因为您声明了data2。

然后你有两个选择（如果我理解你试图解决的问题）。

第一个选项是编写一个返回向量的函数。

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
vector<T> doublingFunc(const vector<T> &input){
    vector<T> output;
    /* it is good practice
       to catch the size of the vector
       once so that you aren't calling
       vector::size() each go through
       of the loop, but it is no big deal
    */
    unsigned sz = input.size();
    for(unsigned i=0; i<sz; i++){
        output.push_back(2*input[i]);
    }
    return output;
}

template <typename T>
void printVector(const vector<T> &input){
    unsigned sz = input.size();
    cout<<"========"<<endl;
    for(unsigned i=0; i<sz; i++){
        cout<<input[i]<<endl;
    }
    cout<<"========"<<endl;
}

int main(){
    vector<double> data;

    for(int i=1; i<10; i++){
        data.push_back((double) i);
       //technically, the cast in unnecessary
    }

    printVector(data);

    vector<double> data2 = doublingFunc(data);

    printVector(data2);

    return 0;
}

第二个选项是编写一个动态分配新向量然后返回指向它的指针的函数。

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
vector<T>* doublingFunc(const vector<T> &input){
    vector<T>* output = new vector<T>();
    /* it is good practice
       to catch the size of the vector
       once so that you aren't calling
       vector::size() each go through
       of the loop, but it is no big deal
    */
    unsigned sz = input.size();
    for(unsigned i=0; i<sz; i++){
        output->push_back(2*input[i]);
    }
    return output;
}

template <typename T>
void printVector(const vector<T> &input){
    unsigned sz = input.size();
    cout<<"========"<<endl;
    for(unsigned i=0; i<sz; i++){
        cout<<input[i]<<endl;
    }
    cout<<"========"<<endl;
}

int main(){
    vector<double> data;

    for(int i=1; i<10; i++){
        data.push_back((double) i);
    }

    printVector(data);

    vector<double>* data2 = doublingFunc(data);

    /*this function takes a reference to a vector,
     so we need to dereference the pointer
   */
    printVector(*data2);

    //remember to delete dynamically allocated variables
    delete data2;
    return 0;
}

当然，如果您只想打印出矢量中所有条目值的两倍，您可以使用该函数：

template <typename T>
void printDouble(const vector<T> &input){
    unsigned sz = input.size();
    cout<<"========"<<endl;
    for(unsigned i=0; i<sz; i++){
        cout<<2 * input[i]<<endl;
    }
    cout<<"========"<<endl;
}

这对你来说可能是很多新东西，因为你似乎对c ++很陌生。我建议您浏览this网站。

Answer 3

对于std :: cout来打印std :: vector，你必须重载它的流插入操作符（＆lt;＆lt;）。

e.g。

std::ostream& operator << ( std::ostream& os, const std::vector<double>& v )
{
    os << "{ ";
    for ( const auto& i : v )
    {
        os << i << ' ';
    }
    os << "}";
    return os;
}

要打印容器的内容，可以使用上例中使用的C ++ 11 range-for loop。

您也可以使用std::copy算法进行此重载，或者直接使用它：

std::ostream& operator << ( std::ostream& os, const std::vector<double>& v )
{
    os << "{ ";
    std::copy( begin(v), end(v), std::ostream_iterator<double>( os, " " ) );
    os << "}";
    return os;
}

在你的代码中，你可以简单地使用函数来操作向量的值，然后像这样打印：

void multiplyBy2( vector<double>& v )
{
    for ( auto& i : v )
    {
        i *= 2;
    }
}

int main( void )
{
    vector<double> v;
    // ...
    multiplyBy2( v );
    std::cout << v << std::endl;

    return 0;
}

如何从c ++中的函数返回向量？

3 个答案: