[英]Passing a std::array of unknown type and size to a constructor of a templated function
[英]Passing a std::array of unknown size to a function
在C ++ 11中,我将如何编写采用已知类型但大小未知的std :: array的函数(或方法)?
// made up example
void mulArray(std::array<int, ?>& arr, const int multiplier) {
for(auto& e : arr) {
e *= multiplier;
}
}
// lets imagine these being full of numbers
std::array<int, 17> arr1;
std::array<int, 6> arr2;
std::array<int, 95> arr3;
mulArray(arr1, 3);
mulArray(arr2, 5);
mulArray(arr3, 2);
在搜索过程中,我只发现了使用模板的建议,但是这些建议看起来很混乱(标头中的方法定义),对于我要完成的工作而言,这些建议过多。
有没有一种简单的方法可以像使用普通C样式数组那样进行这项工作?
有没有一种简单的方法可以像使用普通C样式数组那样进行这项工作?
否。除非您将函数设为函数模板 (或使用其他类型的容器,如问题注释中建议的std::vector
,否则您实际上无法做到这一点:
template<std::size_t SIZE>
void mulArray(std::array<int, SIZE>& arr, const int multiplier) {
for(auto& e : arr) {
e *= multiplier;
}
}
这是一个生动的例子 。
array
的大小是type的一部分 ,因此您无法完全执行所需的操作。 有两种选择。
首选采用一对迭代器:
template <typename Iter>
void mulArray(Iter first, Iter last, const int multiplier) {
for(; first != last; ++first) {
*first *= multiplier;
}
}
或者,使用vector
而不是数组,它允许您在运行时存储大小,而不是将其作为类型的一部分:
void mulArray(std::vector<int>& arr, const int multiplier) {
for(auto& e : arr) {
e *= multiplier;
}
}
我在下面尝试过,它只是为我工作。
#include <iostream>
#include <array>
using namespace std;
// made up example
void mulArray(auto &arr, const int multiplier)
{
for(auto& e : arr)
{
e *= multiplier;
}
}
void dispArray(auto &arr)
{
for(auto& e : arr)
{
std::cout << e << " ";
}
std::cout << endl;
}
int main()
{
// lets imagine these being full of numbers
std::array<int, 7> arr1 = {1, 2, 3, 4, 5, 6, 7};
std::array<int, 6> arr2 = {2, 4, 6, 8, 10, 12};
std::array<int, 9> arr3 = {1, 1, 1, 1, 1, 1, 1, 1, 1};
dispArray(arr1);
dispArray(arr2);
dispArray(arr3);
mulArray(arr1, 3);
mulArray(arr2, 5);
mulArray(arr3, 2);
dispArray(arr1);
dispArray(arr2);
dispArray(arr3);
return 0;
}
输出:
1 2 3 4 5 6 7
2 4 6 8 10 12
1 1 1 1 1 1 1 1 1
3 6 9 12 15 18 21
10 20 30 40 50 60
2 2 2 2 2 2 2 2 2
编辑
C ++ 20暂时包含std::span
https://en.cppreference.com/w/cpp/container/span
原始答案
您想要的是gsl::span
类的东西,可在C ++核心准则中描述的准则支持库中找到:
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#SS-views
您可以在此处找到GSL的仅开源标头实现:
https://github.com/Microsoft/GSL
使用gsl::span
,您可以执行以下操作:
// made up example
void mulArray(gsl::span<int>& arr, const int multiplier) {
for(auto& e : arr) {
e *= multiplier;
}
}
// lets imagine these being full of numbers
std::array<int, 17> arr1;
std::array<int, 6> arr2;
std::array<int, 95> arr3;
mulArray(arr1, 3);
mulArray(arr2, 5);
mulArray(arr3, 2);
std::array
的问题在于它的大小是其类型的一部分,因此您必须使用模板才能实现采用任意大小的std::array
的函数。
另一方面, gsl::span
将其大小存储为运行时信息。 这使您可以使用一个非模板函数来接受任意大小的数组。 它还将接受其他连续容器:
std::vector<int> vec = {1, 2, 3, 4};
int carr[] = {5, 6, 7, 8};
mulArray(vec, 6);
mulArray(carr, 7);
太酷了吧?
绝对,C ++ 11中有一种简单的方法可以编写一个函数,该函数采用已知类型但大小未知的std :: array。
如果我们无法将数组大小传递给函数,则可以传递数组开始处的内存地址和数组结束处的第二地址。 稍后,在函数内部,我们可以使用这两个内存地址来计算数组的大小!
#include <iostream>
#include <array>
// The function that can take a std::array of any size!
void mulArray(int* piStart, int* piLast, int multiplier){
// Calculate the size of the array (how many values it holds)
unsigned int uiArraySize = piLast - piStart;
// print each value held in the array
for (unsigned int uiCount = 0; uiCount < uiArraySize; uiCount++)
std::cout << *(piStart + uiCount) * multiplier << std::endl;
}
int main(){
// initialize an array that can can hold 5 values
std::array<int, 5> iValues;
iValues[0] = 5;
iValues[1] = 10;
iValues[2] = 1;
iValues[3] = 2;
iValues[4] = 4;
// Provide a pointer to both the beginning and end addresses of
// the array.
mulArray(iValues.begin(), iValues.end(), 2);
return 0;
}
控制台输出:10、20、2、4、8
可以做到这一点,但需要花一些步骤才能干净地做。 首先,编写一个代表一系列连续值的template class
。 然后将知道array
大小的template
版本转发到采用此连续范围的Impl
版本。
最后,实现contig_range
版本。 请注意, for( int& x: range )
适用于contig_range
,因为我实现了begin()
和end()
并且指针是迭代器。
template<typename T>
struct contig_range {
T* _begin, _end;
contig_range( T* b, T* e ):_begin(b), _end(e) {}
T const* begin() const { return _begin; }
T const* end() const { return _end; }
T* begin() { return _begin; }
T* end() { return _end; }
contig_range( contig_range const& ) = default;
contig_range( contig_range && ) = default;
contig_range():_begin(nullptr), _end(nullptr) {}
// maybe block `operator=`? contig_range follows reference semantics
// and there really isn't a run time safe `operator=` for reference semantics on
// a range when the RHS is of unknown width...
// I guess I could make it follow pointer semantics and rebase? Dunno
// this being tricky, I am tempted to =delete operator=
template<typename T, std::size_t N>
contig_range( std::array<T, N>& arr ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
template<typename T, std::size_t N>
contig_range( T(&arr)[N] ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
template<typename T, typename A>
contig_range( std::vector<T, A>& arr ): _begin(&*std::begin(arr)), _end(&*std::end(arr)) {}
};
void mulArrayImpl( contig_range<int> arr, const int multiplier );
template<std::size_t N>
void mulArray( std::array<int, N>& arr, const int multiplier ) {
mulArrayImpl( contig_range<int>(arr), multiplier );
}
(未经测试,但设计应该可以使用)。
然后,在您的.cpp
文件中:
void mulArrayImpl(contig_range<int> rng, const int multiplier) {
for(auto& e : rng) {
e *= multiplier;
}
}
不利之处在于,循环遍历数组内容的代码不知道(在编译时)数组的大小,这可能会导致优化。 它的优点是实现不必在标头中。
在显式构造contig_range
要小心,就像您将其传递给set
,它将假定set
数据是连续的,这是错误的,并且在整个地方都发生未定义的行为。 保证可以使用的唯一两个std
容器是vector
和array
(以及C样式的数组,碰巧!)。 尽管可以随机访问,但deque
不连续(危险,它在小块中是连续的!), list
甚至不紧密,并且关联的(有序和无序)容器同样是不连续的。
因此,我在std::array
, std::vector
和C样式的数组中实现了三个构造函数,它们基本上覆盖了基础。
实现[]
也很容易,并且在for()
和[]
之间for()
这是您想要的array
大部分内容,不是吗?
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.