Удалить элементы массива с чётной суммой цифр стоящие между первым минимальным и последним максимальным элементами

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<random>
#include<iostream>
#include<iomanip>
 
 
#define IS_NOT_GIVEN 0x40000000
 
enum
 {
T_INTEGER = 1,
T_DOUBLE
 };
 
enum
 {
AUTOMATICALLY,
MANUALLY
 };
 
union TYPE
 {
double d;
int i;
 };
 
template<typename T>
T get_choice( T limit_0, T limit_1 )
 {
T Answer;
std::cout << "Enter coice: ";
if( limit_0 == IS_NOT_GIVEN ) limit_0 = IS_NOT_GIVEN * -1.0;
while(  !(std::cin >> Answer) || (std::cin.peek() != '\n') 
       || Answer > limit_1 || Answer < limit_0 )
 {
 std::cin.clear();
 std::cin.ignore( (std::numeric_limits<std::streamsize>::max)(), '\n' );
 std::cout << "Input error! Retry again" << std::endl;
 }
return Answer;
 }
 
class USER_T
 {
public:
 
unsigned char cur_type;
 
int size;
USER_T() : size(0), cur_type(0), Array(NULL) {}
~USER_T()
 {
 delete Array;
 }
 
bool create( int, unsigned char );
void display();
 
template<typename T>
bool fill( int mode, T x );
 
void modify();
void delete_element( int );
 
protected:
 
TYPE *Array;
 };
 
template<typename T>
bool USER_T::fill( int mode, T x )
 {
 
if( mode == AUTOMATICALLY )
 {
 std::normal_distribution<> distribution( x, x+200.0 );
 std::mt19937 engine;
 
 for( int i=0; i<size; i++ )
  {
  if( cur_type == 1 ) Array[ i ].i = distribution( engine );
  else Array[ i ].d = distribution( engine );
  }
 }
else
 {
 std::cout << "Insert numbers by yourself:\n";
 for( int i=0; i<size; i++ )
  {
  if( cur_type == 1 ) Array[ i ].i = get_choice<int>( IS_NOT_GIVEN, IS_NOT_GIVEN );
  else Array[ i ].d = get_choice<double>( IS_NOT_GIVEN*1.0, IS_NOT_GIVEN*1.0 );
  }
 }
return true;
 }
 
void USER_T::display()
 {
for( int i=0; i<size; i++ )
 {
 if( cur_type == T_DOUBLE ) std::cout << std::setw(10) << Array[ i ].d << '\n';
 else std::cout << std::setw(10) <<  Array[ i ].i << '\n';
 }
return;
 }
 
bool USER_T::create( int N, unsigned char tvar )
 {
cur_type =  tvar;
size = N;
int Answer;
 
if( cur_type )
 {
 Array = new TYPE [ N ]();
 
 std::cout << "\nMake your choice:\n";
 std::cout << "1. Array will be filled automatically.\n";
 std::cout << "2. Array will need to be filled by yourself.\n";
 
 Answer = get_choice<int>( 1, 2 );
 
 if( Answer == 1 )
  this->fill( AUTOMATICALLY, (cur_type==T_DOUBLE) ? Array[ 0 ].d : Array[ 0 ].i );
 else
  {
  this->fill( MANUALLY, (cur_type==T_DOUBLE) ? Array[ 0 ].d : Array[ 0 ].i );
  }
 }
else 
 {
 std::cout << " Unknown type!" << '\n';
 }
return( Array ) ? true : false;
 }
 
// Target ============
template<typename T> // Grt first minimal element 
int find_milel( TYPE *Array, int SZ, unsigned char type_flag )
 {
T mil = IS_NOT_GIVEN * 1.0;
int index = 0;
for( int i=0; i<SZ; i++ )
 {
 if( type_flag == T_DOUBLE && Array[ i ].d < mil ) { mil = Array[ i ].d; index=i; }
 else if( type_flag == T_INTEGER && Array[ i ].i < mil ) { mil = Array[ i ].i; index=i; }
 }
return index;
 }
 
template<typename T> // Get latest maximal element
int find_malel( TYPE *Array, int SZ, unsigned char type_flag )
 {
T mal = IS_NOT_GIVEN * -1.0;
int index = 0;
for( int i=0; i<SZ; i++ )
 {
 if( type_flag == T_DOUBLE && Array[ i ].d > mal ) { mal = Array[ i ].d; index=i; }
 else if( type_flag == T_INTEGER && Array[ i ].i > mal ) { mal = Array[ i ].i; index=i; }
 }
return index;
 }
 
void USER_T::delete_element( int pos )
 {
for( int i=pos; i<size-1; i++ )
 {
 Array[ i ] = Array[ i+1 ];
 }
--size;
 }
 
template<typename T>
int amount_of_numerals( T number, unsigned char type_flag )
 {
long long sum = 0;
char *buffer = new char[ 12 ], tmp[ 2 ] = {0};
 
if( type_flag == T_DOUBLE ) sprintf( buffer, "%11lf", fabs(number) );
else sprintf( buffer, "%11ld", abs(number) );
 
for( int i=0; i<strlen(buffer); i++ )
 {
 tmp[ 0 ] = buffer[ i ];
 sum += atoi( tmp );
 }
delete buffer;
return sum;
 }
 
void USER_T::modify()
 {
int index_mil = 0, index_mal = 0;
 
if( cur_type == T_DOUBLE )
 {
 index_mil = find_milel<double>( Array, size, cur_type );
 index_mal = find_malel<double>( Array, size, cur_type );
 }
else
 {
 index_mil = find_milel<int>( Array, size, cur_type );
 index_mal = find_malel<int>( Array, size, cur_type );
 }
 
for( int i=index_mil; i<=index_mal; i++ )
 {
 if( !(amount_of_numerals( Array[ i ].d, cur_type) % 2) )
  {
  delete_element( i );
  }
 }
return;
 }
 
// =====================
 
 
 
 
 
int main()
 {
int Answer_1;
USER_T V;
 
std::cout << "\nWhat type are your prefer?\n";
std::cout << "1. integer\n";
std::cout << "2. double\n";
Answer_1 = get_choice<int>( 1, 2 );
 
std::cout << "\nSelect SIZE of array:\n";
int N = get_choice<int>( 1, IS_NOT_GIVEN );
 
V.create( N, Answer_1 );
 
std::cout << "Your array:\n";
V.display();
 
V.modify();
 
std::cout << "\n-------------------\nYour array after modifyed:\n";
V.display();
 
return 0;
 }