Здравствуйте, Посетитель - 356695!
В шаблонах нет ничего сложного. Вы создаёте те же функции, только с расчётом на то, что они могут работать с разными типами. Соответственно, такие функции не должны полагаться на то, что обрабатываемые данные будут иметь какой-то определённый тип. Кроме того, для шаблонов нельзя разносить объявление и реализацию по разным файлам: всё описывается в заголовочном файле (.h). Это связано с тем, что компилятору необходимо подставить реальные типы в функции перед сборкой, а если реализация будет находиться в срр-файле, на данном этапе ему это не удастся и из-за разночтений в заголовке он не сможет найти нужную функцию.
Более подробно можно прочитать, например, здесь.
Реализация вашего задания в приложении. Сумма положительных элементов считается несколько нелогично: считается сначала их количество, затем они в цикле выбираются по порядку. Сделано это мной для того, чтобы использовать шаблонные функции, хотя в данном случае это не слишком уместно.
Проверено в Borland 6. Будут вопросы - задавайте.
Удачи!

Приложение:
//---------------------------------------------------------------------------

#pragma hdrstop
#include <conio.h>
#include <iostream>
#include "templ.h"

using namespace std;

//---------------------------------------------------------------------------
class Predicate : public unary_function<double, bool> //предикат - наследует std::унарную функцию
{
public:
virtual bool operator()(double a) const //фукнция для предиката
{
return a > 0; //в данном случае просто проверяем положительность
}
};

#pragma argsused
int main(int argc, char* argv[])
{
double a [10];
int n = 10;
RandomFill<double> (a, n); //заполняем массив
double s = 0;
int pos = 0, k = CountByCond<double, Predicate>(a, n, Predicate()); //считаем количество положительных
for (int i=1; i<=k; i++) //суммируем очередной положительный элемент
s+=a[FindByCond<double, Predicate>(a, n, i, Predicate())];
cout << "Massiv: ";
for (int i = 0; i<n; i++) { //выводим массив
cout << a[i] << ' ';
a[i] = a[i]<0 ? -1*a[i] : a[i]; //заодно заполняем массив по модулю
}
cout << endl << "Summa: " << s << endl;
int max = Max<double> (a, n); //ищем максимальный и минимальный
int min = Min<double> (a, n);
int beg = max>min ? min : max; //выбираем, который с начала
int end = max<min ? min : max;
double p = 1;
for (int i=beg; i<=end; i++) p*=a[i]; //считаем произведение
cout << "Proizvedenie: " << p << endl;
getch();
return 0;
}
//---------------------------------------------------------------------------

//файл templ.h
//---------------------------------------------------------------------------

#ifndef templH
#define templH

#include <time.h>
#include <stdio.h>

//- заполнение случайными значениями;
template <class T> void RandomFill (T* a, int n)
{
srand (time(NULL)); //инициализация генератора случайных чисел
for (int i=0; i<n; i++) a[i] = (T)(rand ()%(n*n)); //заполнение массива
}

//- файловый ввод/вывод;
template <class T> bool SaveToFile (T* a, int n, const char* fname)
{
FILE* f = fopen (fname, "wb"); //открываем файл для бинарной записи
if (!f) return false; //ошибка, если файл не открылся
if (fwrite (&n, sizeof(int), 1, f)!=1) return false; //пишем в файл размер массива
if (fwrite (a, sizeof(T), n, f)!=n) return false; //пишем элементы
fclose (f); //закрываем файл
return true;
}

template <class T> bool LoadFromFile (T* a, int &n, const char* fname)
{ //аналогично для загрузки из файла
FILE* f = fopen (fname, "rb");
if (!f) return false;
if (fread (&n, sizeof(int), 1, f)!=1) return false;
if (fread (a, sizeof(T), n, f)!=n) return false;
fclose (f);
return true;
}

//- вставка и удаление k-ого элемента в массив;
template <class T> void Insert (T* a, int &n, int k, T el)
{
for (int i=n; i>k; i--) //освобождаем место
a[i] = a[i-1];
a[k] = el; //вставляем элемент
n++;
}

template <class T> void Delete (T* a, int &n, int k)
{
for (int i=k; i<n-1; i++)
a[i] = a[i+1]; //затираем элемент
n--;
}

//- сортировка массива;
template <class T> void Sort (T* a, int n)
{ //сортируем пузырьком
int k;
for (int i=0; i<n-1; i++)
for (int j=0; j<n-i-1; j++)
if (a[j]>a[j+1]) {
k = a[j];
a[j] = a[j+1];
a[j+1] = k;
}
}

//- поиск максимального и минимального элемента;
template <class T> int Max (T* a, int n)
{
int max = 0;
for (int i=1; i<n; i++) //сравниваем все элементы с максимальным, переписываем, если находим больший
if (a[i]>a[max]) max = i;
return max;
}

template <class T> int Min (T* a, int n)
{ //аналогично для минимального
int min = 0;
for (int i=1; i<n; i++)
if (a[i]<a[min]) min = i;
return min;
}

//- поиск k-ого элемента (положительного, отрицательного, нулевого и др.) с применением предикатов;
template <class T, class Predicate> int FindByCond (T* a, int n, int k, Predicate cond)
{
int c = 0;
for (int i=0; i<n; i++)
if (cond(a[i])) { //проверяем элемент на выполнение заданного предиката
c++; //считаем количество
if (c==k) return i; //если достигли заданного - выходим
}
return -1; //не нашли
}

//- подсчет количества элементов с указанной характеристикой (положительные, отрицательные, нулевые, кратные m) с применением предикатов;
template <class T, class Predicate> int CountByCond (T* a, int n, Predicate cond)
{ //аналогично предыдущему, но просто считаем количество
int c = 0;
for (int i=0; i<n; i++)
if (cond(a[i]))
c++;
return c;
}


//---------------------------------------------------------------------------
#endif