Question

我正在使用Visual Studio2017。我在全局范围内定义了两个2D向量：

std::vector<std::vector<double>> my_vector1;
std::vector<std::vector<double>> my_vector2;

在全局范围内也定义了许多全局常量和参数：

double my_parameter1 = 1;
/* lots of other constants and variables here*/

然后我有一个函数，需要根据传递给函数的参数来访问向量之一和特定的全局参数：

double MakeCalculations(int vector_to_use){

  std::vector<std::vector<double>> my_vector;
  double my_parameter;     
  /*lots of other variables here */

  if(vector_to_use == 1){                         //use first vector
    my_vector = &my_vector1;                      //doesn't work
    /*assigning values for lots of parameters*/
  }
  else{                                           //use second vector
    my_vector = &my_vector2;                      //doesn't work
    /*assigning values for lots of parameters*/
  }

  /*performing calculations with my_vector here*/
}

然后：

int main(){
  my_vector1.resize(sizei1, std::vector<double>(sizej1, 0)); //initializing 2D vector
  my_vector2.resize(sizei2, std::vector<double>(sizej2, 0)); //initializing 2D vector

  /*using function MakeCalculations here alot*/
}

如何根据传递的参数my_vector使变量my_vector1成为对my_vector2或vector_to_use的引用？

谢谢

Answer 1

最需要解决的问题是，在需要对已编写的代码进行最少更改的同时，使用临时指针变量。

  std::vector<std::vector<double>>* tmp_ptr;
  double my_parameter;     
  /*lots of other variables here */

  if (vector_to_use == 1) {                         //use first vector
    tmp_ptr = &my_vector1;
    /*assigning values for lots of parameters*/
  }
  else{                                           //use second vector
    tmp_ptr = &my_vector2;
    /*assigning values for lots of parameters*/
  }
  std::vector<std::vector<double>>& my_vector = *tmp_ptr;

  /*performing calculations with my_vector here*/
}

Answer 2

在这一行上，您尝试获取my_vector1的地址，并将其填充到向量类型的变量中：

my_vector = &my_vector1;

表达式'&my_myvector1'的结果是指针类型的值，或更具体地说，是std::vector<std::vector<double>>*的值（请注意结尾的星号）。一种选择是将“ my_vector1”的类型更改为std::vector<std::vector<double>>*的类型，并将对其成员的每次访问更改为使用->语法而不是.

另一个选择是使my_vector成为引用，但是在当前代码下这是不可能的，因为必须在声明时初始化引用类型的变量。但是，您可以通过将代码稍微重构为类似的方式来实现：

std::vector<std::vector<double>>& my_vector = DetermineVectorToUse(vector_to_use)

DetermineVectorToUse为：

std::vector<std::vector<double>>& DetermineVectorToUse(int vector_to_use) { if (vector_to_use == 1) { return my_vector1; } etc. }

请注意，vector_to_use的每个值都必须有一个向量，因为您总是必须（或至少要）返回对超出函数范围的向量的有效引用。

Answer 3

只需将局部变量“ my_vector”的类型更改为指针即可。

std::vector<std::vector<double>>* my_vector;

然后，您将必须使用->访问变量，如下所示：

std::cout << my_vector->at(0).at(0) << std::endl;

工作版本：

double MakeCalculations(int vector_to_use) {

std::vector<std::vector<double>>* my_vector;
double my_parameter;
/*lots of other variables here */

if (vector_to_use == 1) {                         //use first vector
    my_vector = &my_vector1;                      //doesn't work
                                                  /*assigning values for lots of parameters*/
}
else {                                           //use second vector
    my_vector = &my_vector2;                      //doesn't work
                                                  /*assigning values for lots of parameters*/
}
std::cout << my_vector->at(0).at(0) << std::endl;
my_vector->at(0).at(0) = 88;

/*performing calculations with my_vector here*/
return 0;}

Answer 4

这不是要回答OP问题。

我想补充一下，如果您的二维尺寸至少在一个尺寸上固定了。如果将其创建为数组的 vector 类型，则可以拥有诸如内置数组之类的2D数据。

#include <iostream> // cout
#include <vector>   // vector
#include <array>    // array
#include <iomanip>  // fixed, setprecision

constexpr size_t col_c = 10;
size_t row = 5;

using row_t = std::array<double,col_c>;
using vec2d_t = std::vector<row_t>;
auto make_2d_of_row(size_t row) -> vec2d_t {
    return vec2d_t(row,row_t{});
}

int main()
{
  auto vec1 = make_2d_of_row(row);
  auto vec2 = make_2d_of_row(row);

  auto init = 0.0;
  for (size_t row = 0; row < vec1.size(); ++row) {
    for (size_t col = 0; col < col_c; ++col) {
      vec1[row][col] = (init += 0.1);
    }
  }

  std::cout << std::fixed << std::setprecision(1);

  for (size_t row = 0; row < vec1.size(); ++row) {
    for (size_t col = 0; col < col_c; ++col) {
      std::cout << vec1[row][col] << " ";
    }
    std::cout << "\n";
  }

}

打印

0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 
2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 
3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 4.0 
4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 5.0

当然，您也可以像约翰的答案一样从选择性指针中调用引用。

vec2d_t* tmp_ptr;
....
vec2d_t& my_vector = *tmp_ptr;

godbolt.org/g/ZaqmBs

wandbox.org/permlink/U3ynShvUnqkBYim2

如何通过参考或指针访问2D向量

4 个答案: