How to get range like this in an array using C/C++?

You can use a simple loop, saving the last start range. A straightforward implementation in C++:

#include <utility>
#include <vector>

vector<pair<size_t, size_t> > getRanges (vector<double> array)
{
    vector<pair<size_t, size_t> > result;
    size_t indexLastStart = 0;
    double valueLastStart = array[0];

    for (size_t i = 1; i < array.size(); i++)
    {
        if (array[i] - valueLastStart > 5.0)
        {
            result.push_back(make_pair(indexLastStart, i - 1));
            indexLastStart = i;
            valueLastStart = array[i];
        }
    }

    result.push_back(make_pair(indexLastStart, array.size() - 1));
    return result;
}

You can use this function as follow:

int main()
{
    double t[] = { 
        0.0,
        0.01,
        0.02,
        0.03,
        5.04,
        6.05,
        7.06,
        13.07,
        20.08,
        22.09
    };
    vector<double> a(t, t + sizeof t / sizeof *t);
    vector<pair<size_t, size_t> > r = getRanges(a);

    for (size_t i = 0; i < r.size(); i++)
        cout << a[r[i].first] << "\t" << a[r[i].second] << endl;

    return 0;
}

In C, it might look something like:

#include <stdio.h>

struct range
{
    int start;
    int end;
};

size_t getRanges(struct range *result, double *array, size_t inputSize)
{
    size_t outputSize = 0;
    size_t indexLastStart = 0;
    double valueLastStart = array[0];
    struct range added;
    size_t i;

    for (i = 1; i < inputSize; i++)
    {
        if (array[i] - valueLastStart > 5.0)
        {
            added.start = indexLastStart;
            added.end = i - 1;

            result[outputSize++] = added;
            indexLastStart = i;
            valueLastStart = array[i];
        }
    }

    added.start = indexLastStart;
    added.end = inputSize - 1;
    result[outputSize++] = added;
    return outputSize;
}

int main()
{
    double t[10] =
    { 
        0.0,
        0.01,
        0.02,
        0.03,
        5.04,
        6.05,
        7.06,
        13.07,
        20.08,
        22.09
    };
    struct range result[10];
    size_t i;
    size_t size = getRanges(result, t, sizeof t / sizeof *t);

    for (i = 0; i < size; i++)
    {
        printf("%.2f\t%.2f\n", t[result[i].start], t[result[i].end]);
    }

    return 0;
}

This algorithm runs in linear time O(n).

#include <iostream>
using namespace std;

int fun(double* arr, int n, double* res)
{
    int start = 0;
    int end   = 0;
    int len   = 0;
    for(int i = start; i < n; ++i)
    {
        if(arr[i]- arr[end] < 5)
        {
            end = i;
        }
        else
        {
            res[len++] = arr[start];
            res[len++] = arr[end];
            start = end = i;
        }
    }
    res[len++] = arr[start];
    res[len++] = arr[end];
    return len;
}

int main()
{
    double t[] = { 
        0.0,
        0.01,
        0.02,
        0.03,
        5.04,
        6.05,
        7.06,
        13.07,
        20.08,
        22.09
    };

    int n = sizeof(t) / sizeof(*t);
    double *res = new double[n];
    int k = fun(t, n, res);
    for(int j = 0; j < k; j += 2)
        cout<<res[j]<<"  "<<res[j+1]<<endl;
 }

Little late, but anyways here is my quite compact implementation for C++.

template <typename T>
std::vector<std::pair<T, T>> generate_pairs(T *first, T *last)
{
    std::vector<std::pair<T, T>> result(std::distance(first, last) / 2);
    std::generate(std::begin(result), std::end(result), [&first] { return std::make_pair(*first++, *first++); });
    return result;
}

int main(int argc, char *argv[])
{
    double arr[] = { 0.0, 0.01, 0.02, 0.03, 5.04, 6.05, 7.06, 13.07, 20.08, 22.09 };

    auto v = generate_pairs(std::begin(arr), std::end(arr));
    for (const auto &p : v)
        cout << "(" << p.first << ", " << p.second << ")" << endl;

    return 0;
}