extract an array from another array at compile time using c++

As mentioned in the comments, the OP is interested also in C++14 based solutions.
Here is one of them:

#include<functional>
#include<cstddef>
#include<utility>
#include<array>

template<std::size_t O, typename T, std::size_t N, std::size_t... I>
constexpr std::array<T, sizeof...(I)>
f(const std::array<T, N> &arr, std::index_sequence<I...>) {
    return { std::get<I+O>(arr)... };
}

template<std::size_t B, std::size_t E, typename T, std::size_t N>
constexpr auto f(const std::array<T, N> &arr) {
    return f<B>(arr, std::make_index_sequence<E-B>());
}

int main() {
    constexpr std::array<int, 3> a1 = { 0, 1, 2 };
    constexpr auto a2 = f<1, 2>(a1);
    static_assert(a1[1] == a2[0], "!");
}

In this case, a2 is equal to { 1 }.
It's worth it checking B and E so as to verify that E is greater than B, but the example should give an idea of what's the way to do it.

To port it to C++11:

• Do not use auto as return type, but explicitly specify std::array (easy)

• Search on the web one of the available C++11 implementations of integer_sequence and make_index_sequence and use it

If it's fine to be explicit about the indexes and not use a range, here is a naïve snippet that should work in C++11:

#include<cstddef>
#include<utility>
#include<array>

template<std::size_t... I, typename T, std::size_t N>
constexpr std::array<T, sizeof...(I)>
f(const std::array<T, N> &arr) {
    return { std::get<I>(arr)... };
}

int main() {
    constexpr std::array<int, 3> a1 = { 0, 1, 2 };
    constexpr auto a2 = f<1>(a1);
    static_assert(a1[1] == a2[0], "!");
}

As in the previous example, a2 is { 1 }.

Here's a solution in C++11 without additives. As usual, compiletime recursion makes do for the lack of C++14's std::index_sequence - in this case by recursively assembling the list of indices that select the desired sample of the data array.

Given some:

constexpr std::array<T,N> data{{...}};

initialized ... with the Ts of your choice, then:

constexpr auto sample = get_sample<Stride,Offset>(data);

will define sample as a compiletime

std::array<T,M>

populated with the M elements of data obtained by selecting the element at offset Offset from the start of successive Stride-sized intervals of data.

#include <array>
#include <type_traits>

constexpr std::size_t 
sample_size(std::size_t size, std::size_t stride, std::size_t off)
{
    return stride == 0 ? 0 : ((size - off) / stride) + 
        (off + (((size - off) / stride) * stride) < size); 
}

template<
    std::size_t Stride = 1, std::size_t Off = 0, 
    typename T, std::size_t Size, std::size_t ...Is
>
constexpr typename std::enable_if<
    sizeof ...(Is) == sample_size(Size,Stride,Off),
    std::array<T, sample_size(Size,Stride,Off)>
>::type
get_sample(std::array<T,Size> const & data)
{
    return std::array<T,sample_size(Size,Stride,Off)>{{data[Is]... }};
}

template<
    std::size_t Stride = 1, std::size_t Off = 0, 
    typename T, std::size_t Size, std::size_t ...Is
>
constexpr typename std::enable_if<
    sizeof ...(Is) != sample_size(Size,Stride,Off),
    std::array<T, sample_size(Size,Stride,Off)>
>::type
get_sample(std::array<T,Size> const & data)
{
    return 
        get_sample<Stride,Off,T,Size,Is...,(sizeof...(Is) * Stride) + Off>
            (data);
}

By default Stride is 1 and Off is 0. The helper function sample_size embeds the convention that if Stride is 0 you get an empty sample.

For an illustrative program, you can append:

constexpr std::array<int,5> data1{{0,1,2,3,4}};
constexpr auto sample1 = get_sample(data1);
constexpr auto sample2 = get_sample<2>(data1);
constexpr auto sample3 = get_sample<2,1>(data1);
constexpr auto sample4 = get_sample<6>(data1);
constexpr auto sample5 = get_sample<6,5>(data1);
static_assert(sample5.size() == 0,"");
constexpr std::array<float,6> data2{{1.1,2.2,3.3,4.4,5.5,6.6}};
constexpr auto sample6 = get_sample<2>(data2);
constexpr auto sample7 = get_sample<2,3>(data2);
constexpr auto sample8 = get_sample<3,2>(data2);
constexpr std::array<int,0> data3{};
constexpr auto sample9 = get_sample<0>(data3);
static_assert(sample9.size() == 0,"");
constexpr auto sample10 = get_sample<2>(data3);
static_assert(sample10.size() == 0,"");

#include <iostream>

int main()
{
    std::cout << "get_sample<> of {0,1,2,3,4}\n";
    for (auto const & e : sample1) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<2> of {0,1,2,3,4}\n";
    for (auto const & e : sample2) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<2,1> of {0,1,2,3,4}\n";
    for (auto const & e : sample3) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<6> of {0,1,2,3,4}\n";
    for (auto const & e : sample4) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<2> of {{1.1,2.2,3.3,4.4,5.5,6.6}}\n";
    for (auto const & e : sample6) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<2,3> of {{1.1,2.2,3.3,4.4,5.5,6.6}}\n";
    for (auto const & e : sample7) {
        std::cout << e << ' ';
    }
    std::cout << '\n';
    std::cout << "get_sample<3,2> of {{1.1,2.2,3.3,4.4,5.5,6.6}}\n";
    for (auto const & e : sample8) {
        std::cout << e << ' ';
    }
    std::cout << '\n';

    return 0;
}

which reports:

get_sample<> of {0,1,2,3,4}
0 1 2 3 4 
get_sample<2> of {0,1,2,3,4}
0 2 4 
get_sample<2,1> of {0,1,2,3,4}
1 3 
get_sample<6> of {0,1,2,3,4}
0 
get_sample<2> of {1.1,2.2,3.3,4.4,5.5,6.6}
1.1 3.3 5.5 
get_sample<2,3> of {1.1,2.2,3.3,4.4,5.5,6.6}
4.4 6.6 
get_sample<3,2> of {1.1,2.2,3.3,4.4,5.5,6.6}
3.3 6.6 

See it live

If you want to apply this to your class Def, you would redefine it in an amenable way like:

struct Def {
  static constexpr int N = 5;
  static constexpr std::array<double,N> data{{0,1,2,3,4}};
};

and get your compiletime sample like:

constexpr auto s = get_sample<2,1>(Def::data);

(g++ 6.1/clang++ 3.8, -std=c++11 -Wall -Wextra -pedantic)