Бросок C++ к массиву меньшего размера

Я полагаю, вы могли бы использовать специализацию шаблона функции, как это (упрощенный пример, где первый аргумент был проигнорирован, а имя функции было заменено на f () и т. Д.):

#include <iostream>
using namespace std;

class X
{
};

template<int sz, int n>
int f(X (&x)[sz])
{
    cout<<"process "<<n<<" entries in a "<<sz<<"-dimensional array"<<endl;
    int partial_result=f<sz,n-1>(x);
    cout<<"process last entry..."<<endl;

    return n;
}
//template specialization for sz=5 and n=4 (number of entries to process)
template<>
int f<5,4>(X (&x)[5])
{
    cout<<"process only the first "<<4<<" entries here..."<<endl;

    return 4;
}


int main(void)
{
    X u[5];

    int res=f<5,5>(u);
    return 0;
}

Конечно, вам придется позаботиться о других ( потенциально опасно) особые случаи , такие как n = {0,1,2,3}, и вам, вероятно, лучше использовать беззнаковые целые числа вместо целых.

Я бы использовал std :: vector или (это действительно плохо и не должно использоваться) в некоторых крайних случаях вы даже можете использовать простой массивы через указатель типа Point * и тогда у вас не должно возникнуть таких "кастингов" проблем.

Почему бы вам просто не передать стандартный указатель вместо указателя размера, как этот

void RectToPointArray(const degRect& rect, degPoint * points ) ;

Я не думаю, что вы правильно формулируете / думаете о проблеме. Обычно вам не нужно конкретно вводить объект с 4 вершинами по сравнению с объектом, имеющим 5.

Но если вы ДОЛЖНЫ ввести его, то вместо этого вы можете использовать struct s для конкретного определения типов. .

struct Coord
{
    float lat, long ;
} ;

Затем

struct Rectangle
{
    Coord points[ 4 ] ;
} ;

struct Pentagon
{
    Coord points[ 5 ] ;
} ;

Затем,

// 4 pt version
void RectToPointArray(const degRect& rect, const Rectangle& rectangle ) ;

// 5 pt version
void RectToPointArray(const degRect& rect, const Pentagon& pent ) ;

Я думаю, что это решение немного экстремально, и std :: vector , который вы проверяете, его размер (4 или 5) как и ожидалось с assert s, подойдет.

Итак, мой вопрос: существует ли безопасный для типов способ приведения массива одного размера в массив меньшего размера где тип массива одинаков?

Нет. Я не думаю, что язык вообще позволяет это сделать: рассмотрим приведение int[10] к int[5]. Однако вы всегда можете получить указатель на него, но мы не можем "обмануть" компилятор, заставив его думать, что массив фиксированного размера имеет другое число измерений.

Если вы не собираетесь использовать std::vector или какой-нибудь другой контейнер, который может правильно определить количество точек внутри во время выполнения и сделать все это удобно в одной функции вместо двух перегрузок функций, которые вызываются в зависимости от количества элементов, а не пытаться делать безумные приведения, рассмотрите это по крайней мере как улучшение:

void RectToPointArray(const degRect& rect, degPoint* points, unsigned int size);

Если вы настроены на работу с массивами, вы все еще можете определить общую функцию, такую как эта:

template <class T, size_t N>
std::size_t array_size(const T(&/*array*/)[N])
{
    return N;
}

... и использовать ее при вызове RectToPointArray для передачи аргумента 'size'. Тогда у вас будет размер, который вы сможете определить во время выполнения, и достаточно легко работать с size - 1, или, что более уместно в данном случае, просто поместить простой оператор if, чтобы проверить, есть ли 5 элементов или 4.

Позже, если вы передумаете и будете использовать std::vector, Boost.Array и т.д., вы сможете использовать эту старую функцию без изменений. Она требует только, чтобы данные были непрерывными и изменяемыми. Вы можете пофантазировать и применить очень общие решения, которые, скажем, требуют только прямых итераторов. Однако я не думаю, что эта проблема достаточно сложна, чтобы оправдать такое решение: это все равно что использовать пушку, чтобы убить муху; мухобойка - это нормально.

Если вы действительно настроены на то решение, которое у вас есть, то сделать это достаточно просто:

template <size_t N>
void RectToPointArray(const degRect& rect, degPoint(&points)[N])
{
    assert(N >= 4 && "points requires at least 4 elements!");
    points[0].lat = rect.nw.lat; points[0].lon = rect.nw.lon;
    points[1].lat = rect.nw.lat; points[1].lon = rect.se.lon;
    points[2].lat = rect.se.lat; points[2].lon = rect.se.lon;
    points[3].lat = rect.se.lat; points[3].lon = rect.nw.lon;

    if (N >= 5)
        points[4].lat = rect.nw.lat; points[4].lon = rect.nw.lon;
}

Да, здесь есть одна ненужная проверка во время выполнения, но попытка сделать это во время компиляции, вероятно, аналогична извлечению вещей из бардачка в попытке увеличить топливную эффективность вашего автомобиля. Поскольку N является константным выражением времени компиляции, компилятор, скорее всего, распознает, что условие всегда ложно, когда N < 5, и просто удалит весь этот участок кода.