Question

我想编写一个接受数组作为输入参数的函数。并且该函数应该打印数组的所有元素。

print_array(arr)
{
  //print all the elemnts of arr.
}

我不知道该怎么做。

我认为首先我们需要找出传递的数组是1-D还是2-D还是3-D等等......数组

因为，打印以下元素：

                            1-D array, you need only 1 for loop.
                            2-D array, you need only 2 for loop.
                            3-D array, you need only 3 for loop.

但是，我不知道你是如何判断它的1-D，2-D还是N-D阵列。请帮助。

Answer 1

使用C ++ 11的std::rank类型特征，您可以非常容易地找到确切的维数，使用单个重载：

#include <type_traits>
#include <iostream>

template<class T, unsigned N>
void print_dimensions(T (&)[N]){
  static unsigned const dims = std::rank<T>::value + 1;
  std::cout << "It's a " << dims << "-D array, you need "
            << dims << " for-loops\n";
}

但是，您根本不需要std::rank来打印所有元素;这可以通过简单的过载轻松解决：

namespace print_array_detail{
template<class T>
void print(T const& v){ std::cout << v << " "; }
template<class T, unsigned N>
void print(T (&arr)[N]){
  for(unsigned i=0; i < N; ++i)
    print(arr[i]);
  std::cout << "\n";
}
}

template<class T, unsigned N>
void print_array(T (&arr)[N]){ print_array_detail::print(arr); }

Live example.

Answer 2

您可以通过模板和C ++中的重载来实现这一目的。考虑

template<size_t X, size_t Y>
int sum_array_dimensions(int (&arr)[X][Y])
{
  // it's 2d
  return X + Y;
}

template<size_t X, size_t Y, size_t Z>
int sum_array_dimensions(int (&arr)[X][Y][Z])
{
  // it's 3d
  return X + Y + Z;
}

Answer 3

您可以在参数中编码维数，并传递一维数组

#define N1 10
#define N2 100
void function(unsigned dimensions, int* array)
{ switch(dimension):
  { case 1:
      for (int i=0;i<N;i++)
      { ... array[i] ...
      }
      break;
    case 2:
      for (int i=0;i<N;i++)
      { for (int j=0;j<N;j++)
        { ... array[i*N+j] ...
        }
      }
      break;
    case 3:
      for (int i=0;i<N;i++)
      { for (int j=0;j<N;j++)
        { for (int k=0;k<N;k++)
          { ... array[i*N2+j*N+k] ...
          }
        }
      }
      break;
  }
}

如果N是2的幂，您可以使用<<左移（x*2^n == x<<n）来优化乘法修改扩展解决方案

// the array is 0-indexed
void function(unsigned* dimensions, int* array)
{ //dimensions[0] = number of dimensions
  //dimensions[1 ... dimensions[0] ] the dimensions themselves
  for(int i=1,n=1;i<=dimensions[0];i++)
  { n*=dimensions[i]; }
  /* if the order in the array happens to be the wanted one */
  for(int i=1;i<=n;i++)
  { print( array[i] );
  }
  /* otherwise the dimensions are specified in the dimension array */
  for(int i=1;i<=n;i++)
  { int k=0;
    int temp=i;
    int base=1;       
    for(int j=1;j<=dimensions[0];j++)
    { k+=(temp%dimension[j])*base;
      base*=dimension[j];
      temp/=dimension[j];
    }
    print(array[k]);
  }   
  */

Answer 4

正如其他人所说，当你将它传递给一个函数时，数组的大小会丢失（除非你通过引用传递）。所以你可以这样做：

/* this function does the work */
template <typename T>
void bar(T* arr, size_t n_dims, size_t* sizes)
{
    std::cout << n_dims << " dimension(s)\n";
    for (size_t i = 0; i < n_dims; ++i)   // for each dimension
        for (size_t j = 0; j < sizes[i]; ++j) ; // for each element
}

/* These are helper overloads to call bar with correct arguments. */
/* You'll need to provide one for each number of dimension you want to support */

template<typename T, size_t N>
void foo(T (&arr)[N])
{
    size_t sizes[] = {N};
    bar(arr, 1, sizes);
}

template<typename T, size_t N, size_t M>
void foo(T (&arr)[N][M])
{
    size_t sizes[] = {N, M};
    bar(arr, 2, sizes);
}

template<typename T, size_t N, size_t M, size_t O>
void foo(T (&arr)[N][M][O])
{
    size_t sizes[] = {N, M, O};
    bar(arr, 3, sizes);
}

int main()
{
    int arr1[42];
    int arr2[2][2];
    int arr3[2][3][4];
    foo(arr1);
    foo(arr2);
    foo(arr3);
}

Live example.

Answer 5

你不能这样做。但是你可以编写3个不同的函数，它们具有相同的名称和不同的参数（diff数组类型），然后每个函数都会处理它自己的数组。

如何确定传递的数组是1-D，2-D还是N-D数组

5 个答案: