C++ 从C+；中的现有数组创建子数组的最佳方法是什么+；？

好的，我正在尝试从一个现有的数组中获取一个子数组，但我不知道如何做。在我的示例中，我有一个非常大的数组，但我想从数组的最后5个元素创建一个数组

我所说的一个例子是：

int array1 = {1,2,3,...99,100};
int array2[5] = array1+95;

我知道这是不对的，但我在做正确的事情时遇到了一些困难。我想得到数组1中的元素96到100，然后把它们放到数组2中，但我不想复制数组。我只希望array2从96元素开始，这样array1[96]和array2[0]将指向相同的位置。

对于此：

"such that array1[96] and array2[0] would be pointing to the same location."

你可以做：

int *arr2 = arr1 + 96;
assert(arr2[0] == arr1[96] == 97);

---

您说过不想复制数组，但要获取指向最后五个元素的指针。你差点就成功了：

int array1[] = {1,2,3,...99,100};
int* array2  = &array1[95];

---

<>在C++中，可以使用int指针作为int数组，因此在ARARY1中获得ARARY2在项目96中是很容易的，但是没有任何方法可以让AARYA2具有大小限制，因此您可以这样做< /P> int-array2[]=&array1[96]

还是这个

但不是这个

int array2[5] = &array1[96]; // this doesn't work.

另一方面，C++并没有强制执行数组大小限制，所以唯一的真正损失是不能使用siZeof来获得数组中元素的数量。 注意：

&array1[96]

与

数组+96

编辑：更正-

int-array[]=&array[96]

无效，在声明函数参数列表时，只能将[]用作*的同义词

所以这是允许的

extern int foo(int array2[]);
foo (&array1[96]);

intarr[]={1,2,3,4,5}；
int-arr1[2]；
副本（arr+3、arr+5、arr1）；
对于（int i=0；i<2；i++）
cout一个C程序员的参考黑客，他愿意破坏类型系统以获得有效的：

int (&array2)[5] = (int (&)[5])(*(array1 + 5));

<>现在>代码> ARARY2将是一个数组，用于所有意图和目的，将是一个子数组的代码> ARARY1，甚至可以通过那个著名C++（>代码> ARRAYLYSIZE < /COD>模板函数）。尽管处理这种黑客行为的最好方法是用更多的黑客来隐藏它

#define make_sub_array(type, arr, off, len) (type (&)[len])(*(arr + off));

int (&array2)[5] = make_sub_array(int, array1, 5, 5);

很好。从某些标准来看，这很糟糕，但最终结果a）看起来很整洁，b）完全符合您的要求，c）在功能上与实际数组完全相同，并且d）还具有与原始数组相同的引用的额外优点（或错误特性），因此这两个特性一起更改

更新：如果愿意，模板版本（有点）：

模板
T（&U make_sub_array（T（&orig）[M]，size_T o）][]
{
回报率（T（&）[]）（*（原+o））；
}
#定义make_sub_数组（类型，数组，n，o）（类型（&）[n]）make_sub_数组（数组，o）
int（&array2）[5]=生成子数组（int，array1，5，5）；

我们还得通过打字。因为我们的一个参数必须用作强制转换的一部分，所以我们不能完全（IMHO）避免宏。我们可以这样做：

template <typename T, size_t M, size_t N>
T (&make_sub_array(T (&orig)[M], size_t o))[N]
{
    return (T (&)[N])(*(orig + o));
}

int (&array2)[5] = make_sub_array<int, 15, 5>(array1, 5);

模板
T（&make_-sub_数组（T（&orig）[M]，size_-to））[N]
{
返回（T（&）[N]）（*（原+o））；
}
int（&array2）[5]=生成子数组（array1，5）；

但是，这里的目标是使调用代码尽可能干净，而且这个调用有点毛茸茸的。纯宏版本的开销可能最小，在这种情况下可能是最干净的实现方式。
对于完全不同的方法，您可以执行以下操作

vector<int> v0(array1 + 95, array1 + 100);

向量v0（数组1+95，数组1+100）；

或

向量v1（数组1，数组1+100）；
向量v2（v1.begin（）+95，v1.end（））；

这将生成向量元素的真实副本。
可以用来表示数组/容器的“切片”：

#include <iostream>
#include <boost/range.hpp>

int main()
{
    int array[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    // Create a "proxy" of array[5..7]
    // The range implements the concept of a random sequence containter
    boost::iterator_range<int*> subarray(&array[5], &array[7]+1);

    // Output: 3 elements: 5 6 7
    std::cout << subarray.size() << " elements: "
              << subarray[0] << " "
              << subarray[1] << " "
              << subarray[2] << "\n";
}

#包括
#包括
int main（）
{
int数组[]={0,1,2,3,4,5,6,7,8,9}；
//创建数组[5..7]的“代理”
//该范围实现了随机序列容器的概念
boost：：迭代器_范围子数组（&array[5]，&array[7]+1）；
//输出：3个元素：5 6 7
std：：请记住，从技术上讲，您不会通过指向元素来生成子数组。
array1
的第96个元素是
array1[95]
。当您说“将它们放入array2”时，这意味着复制，否则你将如何将它们放入数组2？没有办法做你想做的。你需要复制元素，或者有一个指向
array1
的第96个元素的指针，或者有一个由5个指针组成的数组，让指针
i
指向
array1
的元素
95+i
。你是联合的请更正，我不是想复制“Plating Theme array2”。我很抱歉术语上的混淆。您应该考虑使用
std:：vector
或
boost:：array
而不是c样式的数组。当我尝试时，我遇到了以下错误：无法从“int*”转换为“int[]”
int array2[]=array1+95；
是非法的。应该是int-array1[]={1,2,3，…99100}；int*array2=array1+95；不能用指针初始化数组（方括号）——它可以告诉数组的起始位置，但不能告诉数组的大小。在尝试键入时仍然会出现错误：int-array2[]=&array1[96]。我收到的错误是：无法从“int*”转换为“int[]”@John:
int-array2[]=&array1[96]；
不正确。是的，
int-foo[]
和
int*foo
只能作为函数参数互换。@詹姆斯：它们不是真正的互换。相反，数组可以分解成指针，但它们不一样。@GMan：它们可以作为函数参数互换（不是参数）这与衰变无关，那就是<代码> AsStuts<代码>应该是数学家的断言，而不是C：-谢谢。我花了很多时间，因为我想让它与实际的C++铸造一起工作，但最终我放弃了，使它工作了。（特别是作为模板函数的
make_sub_array
的潜在版本-我在放弃之前也尝试了一段时间）欢迎。@Chris:我的C++-fu不太好，我更喜欢C语言，但我会尝试！这很流畅…呃丑陋…我的意思是，我印象深刻。宏有助于可读性，但array2的声明仍然有点奇怪。+1对于fuI，我可以制作宏
#define make#s
template <typename T, size_t M>
T (&_make_sub_array(T (&orig)[M], size_t o))[]
{
    return (T (&)[])(*(orig + o));
}
#define make_sub_array(type, array, n, o) (type (&)[n])_make_sub_array(array, o)

int (&array2)[5] = make_sub_array(int, array1, 5, 5);

template <typename T, size_t M, size_t N>
T (&make_sub_array(T (&orig)[M], size_t o))[N]
{
    return (T (&)[N])(*(orig + o));
}

int (&array2)[5] = make_sub_array<int, 15, 5>(array1, 5);

vector<int> v0(array1 + 95, array1 + 100);

vector<int> v1(array1, array1 + 100);
vector<int> v2(v1.begin() + 95, v1.end());

#include <iostream>
#include <boost/range.hpp>

int main()
{
    int array[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    // Create a "proxy" of array[5..7]
    // The range implements the concept of a random sequence containter
    boost::iterator_range<int*> subarray(&array[5], &array[7]+1);

    // Output: 3 elements: 5 6 7
    std::cout << subarray.size() << " elements: "
              << subarray[0] << " "
              << subarray[1] << " "
              << subarray[2] << "\n";
}