Д. Стефенс - C++. Сборник рецептов

Требуется найти евклидово расстояние между векторами.

Евклидово расстояние между векторами определяется как квадратный корень суммы квадратов разностей соответствующих элементов. Рассчитать его можно так, как показано в примере 11.22.

Пример 11.22. Расчет расстояния между двумя векторами

#include

#include

using namespace std;

template

double vectorDistance(Iter_T first, Iter_T last, Iter2_T first2) {

double ret = 0.0;

while (first != last) {

double dist = (*first++) - (*first2++);

ret += dist * dist;

}

return ret > 0.0 ? sqrt(ret) : 0.0;

}

int main() {

int v1[] = { 1, 5 };

int v2[] = { 4, 9 };

cout << "distance between vectors (1,5) and (4,9) is ";

cout << vectorDistance(v1, v1 + 2, v2) << endl;

}

Программа примера 11.22 выдает следующий результат.

distance between vectors (1,5) and (4,9) is 5

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

Пример 11.23. Расчет расстояния между векторами с использованием функции inner_product

#include

#include

#include

#include

using namespace std;

template

struct DiffSquared {

Value_T operator()(Value_T x, Value_T y) const {

return (x - y) * (x - y);

}

};

template

double vectorDistance(Iter_T first, Iter_T last, Iter2_T first2) {

double ret = inner_product(first, last, first2, 0.0L,

plus(), DiffSquared());

return ret > 0.0 ? sqrt(ret) : 0.0;

}

int main() {

int v1[] = { 1, 5 };

int v2[] = { 4, 9 };

cout << "distance between vectors (1,5) and (4,9) is ";

cout << vectorDistance(v1, v1 + 2, v2) << endl;

}

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

Имеются смежные числовые ряды и требуется обеспечить доступ к каждому n-му элементу.

В примере 11.24 представлен заголовочный файл, реализующий класс итератора с шагом.

Пример 11.24. stride_iter.hpp

#ifndef STRIDE_ITER_HPP

#define STRIDE_ITER_HPP

#include

#include

template

class stride_iter {

public:

// открытые имена, вводимые typedef

typedef typename std::iterator_traits::value_type value_type;

typedef typename std::iterator_traits::reference reference;

typedef typename std::iterator_traits::difference_type

difference_type;

typedef typename std::iterator_traits::pointer pointer;

typedef std::random_access_iterator_tag iterator_category;

typedef stride_iter self;

// конструкторы

stride_iter() : m(NULL), step(0) {};

stride_iter(const self& x) : m(x.m), step(x.step) {}

stride_iter(Iter_T x, difference_type n) : m(x), step(n) {}

// операторы

self& operator++() { m += step; return *this; }

self operator++(int) { self tmp = *this; m += step; return tmp; }

self& operator+=(difference_type x) { m += x * step; return *this; }

self& operator--() { m -= step; return *this; }

self operator--(int) { self tmp = *this; m -= step; return trap; }

self& operator--(difference type x) { m -= x + step; return *this; }

reference operator[](difference_type n) { return m[n * step]; }

reference operator*() { return *m; }

// дружественные операторы

friend bool operator==(const self& x, const self& y) {

assert(x.step == y.step);

return x.m == y.m;

}

friend bool operator!=(const self& x, const self& y) {

assert(x.step == y.step);

return x.m != y.m;

}

friend bool operator<(const self& x, const self& y) {

assert(x.step == y.step);

return x.m < y.m;

}

friend difference type operator-(const self& x, const self& y) {

assert(x.step == y.step);

return (x.m - y.m) / x.step;

}

friend self operator+(const self& x, difference_type y) {

assert(x.step == y.step);

return x += y * x.step;

}

friend self operator+(difference_type x, const self& y) {

assert(x.step == y.step);

return y += x * x.step;

}

private:

Iter_T m;

difference_type step;

};

#endif

Пример 11.25 показывает, как можно использовать итератор stride_iterиз примера 11.24 для получения доступа к каждому второму элементу последовательности.

Пример 11.25. Применение итератора stride_iter

#include "stride_iter.hpp"

#include

#include

#include

using namespace std;

int main() {

int a[] = { 0, 1, 2, 3, 4, 5, 6, 7 };

stride_iter first(a, 2);

stride_iter last(a + 8, 2);

copy(first, last, ostream_iterator(cout, "\n"));

}

Программа примера 11.25 выдает следующий результат.

0

2

4

6

Итераторы с шагом часто используются при работе с матрицами. Они обеспечивают простой и эффективный способ реализации матриц в виде набора числовых рядов. Представленная в примере 11.24 реализация итератора с шагом выполнена в виде оболочки другого итератора, который передается как параметр шаблона.

Я хотел сделать итератор с шагом совместимым с STL, поэтому пришлось выбрать подходящий тип стандартного итератора и удовлетворить его требования. Представленный в примере 11.24 итератор с шагом сделан по образцу итератора с произвольным доступом.

В примере 11.26 я отдельно привел реализацию итератора с шагом (названную kstride_iter), когда размер шага известен на этапе компиляции. Поскольку размер шага передается как параметр шаблона, компилятор может оптимизировать программный код итератора более эффективно, и размер итератора уменьшается.

Пример 11.26. kstride_iter.hpp

#ifndef KSTRIDE_ITER_HPP

#define KSTRIDE_ITER_HPP

#include

template

class kstride_iter {

public:

// открытые имена, вводимые typedef

typedef typename std::iterator_traits::value_type value_type;

typedef typename std::iterator_traits::reference reference;

typedef typename std::iterator_traits::difference_type

difference_type;

typedef typename std::iterator_traits::pointer pointer;

typedef std::random_access_iterator_tag iterator_category;

typedef kstride_iter self;

// конструкторы

kstride_iter() : m(NULL) {} kstride_iter(const self& x) : m(x.m) {}

explicit kstride_iter(Iter_T x) : m(x) {}

// операторы

self& operator++() { m += Step_N; return *this; }

self operator++(int) { self tmp = *this; m += Step_N; return tmp; }

self& operator+=(difference_type x) { m += x * Step_N; return *this; }

self& operator--() { m -= Step_N; return *this; }

self operator--(int) { self tmp = *this; m -= Step_N; return tmp; }

self& operator--(difference_type x) { m -= x * Step_N; return *this; }

reference operator[](difference_type n) { return m[n * Step_N]; }

reference operator*() { return *m; }

// дружественные операторы

friend bool operator==(self x, self y) { return x.m == y.m; }

friend bool operator!=(self x, self y) { return x.m != y.m; }

friend bool operator<(self x, self y) { return x.m < y.m; }