#include <iostream>
#include <conio.h>
#define SIZE 4
using namespace std;
template <typename Type>
class Array
{
private:
Type *m_array;
public:
Array();
~Array();
void In();
Type* Out() const { return *m_array; }
};
class ArrayMin: public Array //тут ошибка
{
public:
ArrayMin();
~ArrayMin();
void Min(Type *array);
};
template <typename Type>
Array<Type>::Array()
{
m_array = new Type[SIZE];
}
template <typename Type>
Array<Type>::~Array()
{
delete []m_array;
}
template <typename Type>
void Array<Type>::In()
{
cout << " Enter a array" << endl;
cout << "---------------" << endl;
for (int i = 0; i < SIZE; i++)
{
cout << " " << i << "-element: ";
cin >> m_array;
}
cout << "---------------" << endl;
}
void ArrayMin::Min(Type *array)
{
for (int i = 0, temp = array[0]; i < SIZE; i++)
{
if (array > temp)
temp = array;
}
cout << "Minimal element: "<< temp << endl;
}
int main()
{
Array<int> A;
ArrayMin<int> B;
A.In();
B.Min(A.Out());
cout << "Press any key..." << endl;
while(!_kbhit());
return 0;
}
[C++] наследование шаблонов
Помогите плиз разобраться в наследовании шаблонов, в лит-ре не нашел :(
Вот задачка:
Вот задачка:
Цитата:
Реализовать класс, наследуемый от шаблонного базового класса.
Базовый класс содержит несколько элементов (два) числового или символьного типа.
В производном классе определить функцию определения минимального из них и вывода на экран.
Базовый класс содержит несколько элементов (два) числового или символьного типа.
В производном классе определить функцию определения минимального из них и вывода на экран.
Код:
class ArrayMin: public Array //тут ошибка - не указана реализация шаблона
Варианты
Варианты
Код:
class ArrayInt: public Array <int>
{
// наследуем от реализации шаблона типом int
};
template <typename T> class ArrayMin: public Array <T>
{
// наследуем шаблон от другого шаблона с реализацией шаблонного параметра
};
{
// наследуем от реализации шаблона типом int
};
template <typename T> class ArrayMin: public Array <T>
{
// наследуем шаблон от другого шаблона с реализацией шаблонного параметра
};
Респект el scorpio! Заработало:D
Можно еще пару вопросиков:
1)
В наследуемом классе нужен ли деструктор не по умолчанию?
т.е. небудет ли утечка памяти?(вроде ж когда передается параметр через указатель - он копируется т.е. в данном случае создасться еще один массив(в насл. классе)? или я говорю бред?)
2)
-нельзя как нибудь вместо ArrayMin <int> B; написать ArrayMin <Т> B;
т.е чтоб тип передавало как нить...
p/s извиняюсь если чо сморозил...
Можно еще пару вопросиков:
1)
Код:
template <typename T>
class ArrayMin: public Array <T>
//class ArrayMin: public Array <int>
{
public:
void Min(int *array);
};
class ArrayMin: public Array <T>
//class ArrayMin: public Array <int>
{
public:
void Min(int *array);
};
В наследуемом классе нужен ли деструктор не по умолчанию?
т.е. небудет ли утечка памяти?(вроде ж когда передается параметр через указатель - он копируется т.е. в данном случае создасться еще один массив(в насл. классе)? или я говорю бред?)
2)
Код:
int main()
{
Array <int> A;
ArrayMin <int> B;
A.In();
B.Min(A.Out());
return 0;
}
{
Array <int> A;
ArrayMin <int> B;
A.In();
B.Min(A.Out());
return 0;
}
-нельзя как нибудь вместо ArrayMin <int> B; написать ArrayMin <Т> B;
т.е чтоб тип передавало как нить...
p/s извиняюсь если чо сморозил...
"Респект" репутацию не поднимает ;)
Деструкторы нужны везде, где используются поля-указатели и создаются объекты. Именно во избежание "утечек памяти" при удалении объекта-"владельца".
Array <int> A;
ArrayMin <int> B;
-нельзя как нибудь вместо ArrayMin <int> B; написать ArrayMin <Т> B;
Деструкторы нужны везде, где используются поля-указатели и создаются объекты. Именно во избежание "утечек памяти" при удалении объекта-"владельца".
Цитата:
Array <int> A;
ArrayMin <int> B;
-нельзя как нибудь вместо ArrayMin <int> B; написать ArrayMin <Т> B;
Нет. Потому что типа T нет :D. А даже если бы и был такой свой класс, то реализация произошла бы именно типом T.
В первой строке создаём реализацию шаблона Array типом int.
Во второй - реализацию шаблона ArrayMin типом int. Реализация "родительского класса" для этого объекта производится также типом int
Посмотри плиз все ли правильно?:)
Да и +1;)
Да и +1;)
Код:
#include <iostream>
#include <conio.h>
#define SIZE 4
using namespace std;
//---------------------------------------------------------------------------
template <typename Type>
class Array
{
private:
Type *m_array;
public:
Array();
~Array();
void In();
Type* Out() const { return m_array; }
};
//---------------------------------------------------------------------------
template <typename T>
class ArrayMin: public Array <T>
//или class ArrayMin: public Array <int>
{
public:
ArrayMin(); // не работает,
~ArrayMin(); // или это ненадо?
void Min(int *array);
};
//---------------------------------------------------------------------------
template <typename Type>
Array <Type>::Array()
{
m_array = new Type[SIZE];
if(!m_array) exit(1);
}
//---------------------------------------------------------------------------
template <typename Type>
Array <Type>::~Array()
{
delete []m_array;
}
//---------------------------------------------------------------------------
template <typename T>
ArrayMin <T>::~ArrayMin()
{
delete []array; //пишет что необъявленый индефикатор, но как тогда освободить память?
}
//---------------------------------------------------------------------------
template <typename Type>
void Array <Type>::In()
{
cout << "Enter a array ("
<< SIZE << "-elements)" << endl;
cout << "--------------------------" << endl;
for (int i = 0; i < SIZE; i++)
{
cout << i << "-element: ";
cin >> m_array;
}
cout << "--------------------------" << endl;
}
//---------------------------------------------------------------------------
template <typename T>
void ArrayMin <T>::Min(int *array)
//или void ArrayMin::Min(int *array)
{
for (int i = 0, temp = array[0]; i < SIZE; i++)
{
if (array < temp)
temp = array;
}
cout << "Minimal element: "<< temp << endl;
cout << "--------------------------" << endl;
}
//---------------------------------------------------------------------------
int main()
{
Array <int> A;
ArrayMin <int> B;
//или ArrayMin B;
A.In();
B.Min(A.Out());
cout << "Press any key ";
while(!_kbhit());
return 0;
}
#include <conio.h>
#define SIZE 4
using namespace std;
//---------------------------------------------------------------------------
template <typename Type>
class Array
{
private:
Type *m_array;
public:
Array();
~Array();
void In();
Type* Out() const { return m_array; }
};
//---------------------------------------------------------------------------
template <typename T>
class ArrayMin: public Array <T>
//или class ArrayMin: public Array <int>
{
public:
ArrayMin(); // не работает,
~ArrayMin(); // или это ненадо?
void Min(int *array);
};
//---------------------------------------------------------------------------
template <typename Type>
Array <Type>::Array()
{
m_array = new Type[SIZE];
if(!m_array) exit(1);
}
//---------------------------------------------------------------------------
template <typename Type>
Array <Type>::~Array()
{
delete []m_array;
}
//---------------------------------------------------------------------------
template <typename T>
ArrayMin <T>::~ArrayMin()
{
delete []array; //пишет что необъявленый индефикатор, но как тогда освободить память?
}
//---------------------------------------------------------------------------
template <typename Type>
void Array <Type>::In()
{
cout << "Enter a array ("
<< SIZE << "-elements)" << endl;
cout << "--------------------------" << endl;
for (int i = 0; i < SIZE; i++)
{
cout << i << "-element: ";
cin >> m_array;
}
cout << "--------------------------" << endl;
}
//---------------------------------------------------------------------------
template <typename T>
void ArrayMin <T>::Min(int *array)
//или void ArrayMin::Min(int *array)
{
for (int i = 0, temp = array[0]; i < SIZE; i++)
{
if (array < temp)
temp = array;
}
cout << "Minimal element: "<< temp << endl;
cout << "--------------------------" << endl;
}
//---------------------------------------------------------------------------
int main()
{
Array <int> A;
ArrayMin <int> B;
//или ArrayMin B;
A.In();
B.Min(A.Out());
cout << "Press any key ";
while(!_kbhit());
return 0;
}
Код:
template <typename T>
ArrayMin <T>::~ArrayMin()
{
//delete []array; //пишет что необъявленый индефикатор, но как тогда освободить память?
delete [] m_array;
}
ArrayMin <T>::~ArrayMin()
{
//delete []array; //пишет что необъявленый индефикатор, но как тогда освободить память?
delete [] m_array;
}
[COLOR=red]используй тэги code.[/COLOR]