Function to get minimal value of array in template - c++

Question

I have this code in main:
Array<int> array1 = Array<int>(5);
array1.coutArray();
cout << "Minimal value: " << min(array1, 5);
And I need function to get minimal value of array. I Tried this function:
template<class Array>
Array min(const Array* data, int size) {
T result = data[0];
for (int i = 1; i < size; i++)
if (result > data[i])
result = data[i];
return result;
}
But for every variant from internet I have one error about types of first argument. How to properly write this function or it's calling?
Array class:
template <class T>
class Array {
protected:
int size;
T* DynamicArray;
public:
Array() {};
Array(size_t s) : size(s) {
DynamicArray = new T[size];
for (int i = 0; i < size; i++) {
cout << "Element " << i+1 << ": ";
cin >> DynamicArray[i];
}
}
void coutArray() {
for (int i = 0; i < size; i++) {
cout << DynamicArray[i] << " ";
}
}
~Array() {
delete[]DynamicArray;
}
};
template<class Array>
Array getMin(Array* arr, int size)
{
for (int i = 0; i < size; i++) {
cout << arr[i];
}
}

Answer 1

If you need this for your Array template, it would be best to provide begin and end for it:
template <class T>
class Array {
protected:
int size;
T* DynamicArray;
public:
....
using value_type = T;
const T* begin() const {
return DynamicArray;
}
const T* end() const {
return DynamicArray + size;
}
T* begin() {
return DynamicArray;
}
T* end() {
return DynamicArray + size;
}
};
Then you should be able use STL algorithms.
template<typename T>
T minimum(const T &tab)
{
return *std::minimum_element(std::begin(tab), std::end(tab));
}
Note that your array is poor version of std::vector.

Answer 2

The function getMin should be either a member function of the class or a friend function of the class to have access to protected data members of the class.
Here is a demonstrative program that shows how the function can be defined as a member function of the class. I also made some minor changes in the class definition.
#include <iostream>
template <class T>
class Array {
protected:
size_t size;
T* DynamicArray;
public:
Array() : size( 0 ), DynamicArray( nullptr ) {}
Array(size_t s) : size(s) {
DynamicArray = new T[size];
for ( size_t i = 0; i < size; i++) {
std::cout << "Element " << i+1 << ": ";
std::cin >> DynamicArray[i];
}
}
void coutArray() const {
for ( size_t i = 0; i < size; i++) {
std::cout << DynamicArray[i] << " ";
}
}
~Array() {
delete[]DynamicArray;
}
const T * getMin() const
{
T *min = DynamicArray;
for ( size_t i = 1; i < size; i++ )
{
if ( DynamicArray[i] < *min ) min = DynamicArray + i;
}
return min;
}
};
int main()
{
Array<int> a( 5 );
const int *min = a.getMin();
if ( min != nullptr ) std::cout << "The minimum is equal to " << *min << '\n';
return 0;
}
The program output might look for example the following way
Element 1: 2
Element 2: 3
Element 3: 1
Element 4: 4
Element 5: 5
The minimum is equal to 1
And below there is a demonstrative program when the function is defined as a non-template friend function of the class.
#include <iostream>
template <class T>
class Array {
protected:
size_t size;
T* DynamicArray;
public:
Array() : size( 0 ), DynamicArray( nullptr ) {}
Array(size_t s) : size(s) {
DynamicArray = new T[size];
for ( size_t i = 0; i < size; i++) {
std::cout << "Element " << i+1 << ": ";
std::cin >> DynamicArray[i];
}
}
void coutArray() const {
for ( size_t i = 0; i < size; i++) {
std::cout << DynamicArray[i] << " ";
}
}
~Array() {
delete[]DynamicArray;
}
friend const T * getMin( const Array &a )
{
T *min = a.DynamicArray;
for ( size_t i = 1; i < a.size; i++ )
{
if ( a.DynamicArray[i] < *min ) min = a.DynamicArray + i;
}
return min;
}
};
int main()
{
Array<int> a( 5 );
const int *min = getMin( a );
if ( min != nullptr ) std::cout << "The minimum is equal to " << *min << '\n';
return 0;
}