Что лучший способ состоит в том, чтобы создать множество sub из множества exisiting в C ++?

Справочник от C Программист готов подорвать систему типа, чтобы получить то, что работает:

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

сейчас Array2 будет массивом для всех намерений и целей, а также будет подразделением Array1 , а также Будет даже проходить в этот знаменитый C ++ Array_Size Функция шаблона. Хотя лучший способ справиться с этим будольником - это скрыть его с большим количеством будто!

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

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

Ницца. Ужасно по некоторым стандартам, но конечный результат а) выглядит довольно аккуратно, б) делает именно то, что вы хотите, в) функционально идентичен фактическому массиву, а d) также будет иметь дополнительный бонус (или неправильную функцию) Одинаковая ссылка на оригинал, поэтому два изменения вместе.

Обновление: если вы предпочитаете, версия для шаблонов (вроде):

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);

, но цель здесь состоит в том, чтобы сделать звонок как можно более чистыми, и этот звонок немного волосатый. Версия Pure-Macro, вероятно, имеет наименее накладные расходы, и, вероятно, является самым чистым для реализации в этом случае.

Для исполняемой программы (в отличие от сценария оболочки) в Linux/Unix используйте fork () и exec (), а затем выйдите из родительского процесса, который вернется в оболочку. Для получения более подробной информации см. справочные страницы или некоторые страницы, например http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html .

Сценарий обертки, состоящий только из:

your_prog_or_script &

Немедленно запустит цель и выйдет. Можно добавить nohup в начало этой строки, чтобы она продолжила работу при выходе из оболочки.

Для совершенно другого подхода можно сделать что-то вроде.

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

или

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

Это сделает реальную копию элементов вашего вектора.

Вы можете использовать Boost :: iterator_range Для представления «ломтики» массивов / контейнеров:

#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";
}

Обратите внимание, что ассортимент итератор «знает» о размере суб-массива. Это даже сделает проверку оценок для вас. Вы не можете получить эту функциональность от простого указателя.

Полезность Boost.range станет более очевидной, как только вы узнаете о контейнерах STL и итераторах.

Если вы в линейной алгебре, Boost.ublas поддерживает диапазоны и ломтики для его матриц и векторов.

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

В C ++ вы можете использовать указатель INT в качестве массива INT, поэтому получение Array2 для начала на элементе 96 в ArrayA1 легко, но нет никакого способа дать Array2 ограничение размера Таким образом, вы можете сделать это

int Array2 [] = & Array1 [96];

ИЛИ это

int *array2 = &array1[96];

Но не это

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

с другой стороны, C ++ не обеспечивает ограничения размера массива в любом случае, поэтому единственным реальным потерям является то, что вы не можете использовать SizeOf, чтобы получить количество элементов в Array2.

Примечание: & Array1 [96] - это то же самое, что и массив + 96

Редактирование: коррекция - INT Array [] = & Array [96] ISN t Действительно, вы можете использовать [] как синоним только для * при объявлении списка параметров функции.

Так что это допускается

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

int arr[] = { 1, 2, 3, 4, 5};
int arr1[2];
copy(arr + 3, arr + 5, arr1);
for(int i = 0; i < 2; i++)
    cout << arr1[i] << endl;

Код не безопасен, если границы не обрабатываются должным образом.

Вы сказали, что не хотите копировать массив, но получите указатель на последние пять элементов. У тебя почти было это:

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