Question

我想在“操纵向量”功能中访问向量，方法与我在下面的代码中使用vector [i]而不是vector-＆gt; at（i）访问数组的方式相同。我试图直接传递向量，而不是像数组一样传递指针。但这似乎破坏了该计划。任何想法如何实现这一目标？我是使用std库的新手，因为我主要有C的经验。

#include <vector>
#include <iostream>
#define vectorsize 5
struct st_test {
    int ii;
    float dd;
};

void manipulatevector(std::vector<struct st_test> *test) {
    test->resize(vectorsize);

    for(int i=0;i<vectorsize;i++) {
        test->at(i).dd = i*0.4f;
        test->at(i).ii = i;
    }
}

void manipulatearray(struct st_test test[vectorsize]) {
    for(int i=0;i<vectorsize;i++) {
        test[i].dd = i*0.4f;
        test[i].ii = i;
    }
}

void main() {
    std::vector<struct st_test> test1;
    manipulatevector(&test1);

    struct st_test test2[vectorsize];
    manipulatearray(test2);

    std::cout << "Vector" << std::endl;
    for(int i=0;i<vectorsize;i++) {
        std::cout << test1.at(i).dd << std::endl;
    }

    std::cout << "Array" << std::endl;
    for(int i=0;i<vectorsize;i++) {
        std::cout << test2[i].dd << std::endl;
    }
}

Answer 1

您是否尝试将矢量作为参考传递？

void manipulatevector(std::vector<struct st_test> &test) {
    test.resize(vectorsize);

    for(int i=0;i<vectorsize;i++) {
        test[i].dd = i*0.4f;
        test[i].ii = i;
    }
}

和

std::vector<struct st_test> test1;
manipulatevector(test1);

Answer 2

您只需使用(*test)[i]代替test->at(i)。

这实际上并不是相同的行为（at vs operator[]），但您可能已经意识到这一点。

Answer 3

将其作为参考而不是指针传递。

void manipulatevector(std::vector<struct st_test> &test) {

然后使用.代替->，可以使用重载[]运算符等内容。

Answer 4

您可以通过引用传递vector并使用[]运算符：

void manipulatevector(std::vector<struct st_test>& test) {
    test.resize(vectorsize);

    for(int i=0;i<vectorsize;i++) {
        test[i].dd = i*0.4f;
        test[i].ii = i;
    }
}

当您直接传递vector时，我假设您按值传递了它：

void manipulatevector(std::vector<struct st_test> test) {

这意味着调用者无法看到manipulatevector()内所做的任何更改。这意味着：

for(int i=0;i<vectorsize;i++) {
    std::cout << test1.at(i).dd << std::endl;
}

会从std::out_of_range引发test.at(i)错误，因为test1不会有vectorsize元素，而是零元素。由于main()中没有异常处理，这会导致程序崩溃。

Answer 5

将void manipulatevector(std::vector<struct st_test> *test)的签名更改为void manipulatevector(std::vector<struct st_test>& test)。然后，您可以在向量上使用operator[]。

Answer 6

这里有不同的选择。您可以通过引用传递向量，这是代码中最简单，更清晰的方法：

 void function( std::vector<type>& v )

现在，在某些商店中，样式指南要求如果您要修改参数，则通过指针传递它，因为它使其在调用地点显式化。在这种情况下，可以使用不同的选项来调用operator[]：

 void function( std::vector<type> *v ){
    (*v)[0] = ....                     // dereference first
    v->operator[](0) = ....            // explicitly cal the operator
    std::vector<type>& vr =*v;
    vr[0] = ....                       // create reference and use that

前两个是等价的，第一个可以说更容易阅读。第二个等同于第一个，因为它取消引用指针然后访问运算符，但是您明确地给引用赋予了一个名称，因此它可以在函数中重用，而不必在所有用途中取消引用。虽然这在技术上创建了一个额外的变量，但编译器很可能会优化参考。

在函数内访问类似数组[]的向量

6 个答案: