Código fuente máximo
IntContainer & ltT & gtIntContainer(int tamaño)
{
increaseSize = tamaño
cantidad = aumentarTamaño
cuenta = 0;
almacenamiento = nuevo T[cantidad];
cout & lt& lt"constructor"
}Plantilla y clase ltT y gt
void IntContainer & ltT & gt*Agregar (elemento T)
{
if(count & gt ; = cantidad)
incremento();
tienda[count] = elemento;
count++;
} plantilla<T clase>
t int container::fetch(int index)const
{
if(index >= 0&&index<count )
Devolver almacenamiento [index ];
Otro
return-1
}
Plantilla& ltT clase & gt
void IntContainer; & ltT & gt*increase()
{
cantidad+= aumentar tamaño;
T * nuevo almacenamiento = nuevo T[cantidad];
for(int I = 0;i<count;i++)
nuevo almacenamiento[I]= almacenamiento[I];
Eliminar[]Almacenamiento;
Almacenamiento = nuevoAlmacenamiento
}
Plantilla<TClass>
IntContainer & ltT & gt::~IntContainer()
{
cout & lt& lt"Eliminar destructor de almacenamiento"
Eliminar [] almacenamiento;
p>}
Archivo de encabezado 2: # ifndef intcontainer
#Definición INTCONTAINER
# include & ltiostream & gt
Usar plantilla estándar de espacio de nombres & clase ltT & gt
Clase IntContainer
{
Privado:
T * almacenamiento;
recuento int;
cantidad int;
int aumentarTamaño//int contenedor(int contenedor & tmp);
int contenedor (int tamaño = 100);
~ int contenedor(); elemento);
T fetch(int index) constante;
int get count()const { return count;} iterador de clase
{
Privado:
int contenedor * c;
int Posición;
Público:
Iterador (IntContainer * contenedor, bool bandera): c (contenedor)
{
if(bandera == verdadero)posición = 0;
if(bandera == fal
se)posición = contenedor->getCount();
}
Operador booleano == (iterador y derecha)
{
Devuelve esto ->position == right.position
}
¡Operador booleano! =(Iterador y derecha)
{
¡Devuelve esta posición -> = posición.correcta
}
Iterador y operador amp++()
{
posición++;
Regresar * this
}
Operador iterador++(int)
{
Iterador tmp = * this
posición++ ;
Devolver tmp
}
operador int *()
{
return c-> buscar(posición);
}
}; iterador comenzar(){return iterator(this, true);}
Iterador end(){return iterator (esto, falso);}
Privado:
aumento vacío();
};Plantilla & ltT Clase & gt
IntContainer & ltT & gtIntContainer(int tamaño)
{
incrementarTamaño = tamaño
cantidad = aumentarTamaño
recuento = 0;
almacenamiento = new T[cantidad];
cout & lt& lt"constructor"
} plantilla & ltT clase & gt
void IntContainer & ltT & gt *add(T elemento)
{
if(count & gt; = cantidad)
Aumentar();
Almacenamiento[count] = elemento;
count++;
}Template<TClass>
p>T IntContainer & ltT & gt* fetch(int index) constante
{
if(index & gt; = 0 & amp& ampindex & lt count)
Devolver almacenamiento[Index];
Otro
return-1;
}
Plantilla <TClass& gt
void IntContainer & ltT & gt*increase()
{
cantidad+= aumentar tamaño;
T * nuevo almacenamiento = nuevo T[cantidad];
for(int I = 0;i<count; i++)
nuevo almacenamiento[I]= almacenamiento[I];
Eliminar[]Almacenamiento;
Almacenamiento = nuevoAlmacenamiento
}
Plantilla & Clase ltT & gt
IntContainer & ltT & gt::~IntContainer()
{
cout & lt& lt "Eliminar destructor de almacenamiento"
Eliminar [] almacenamiento;
}
#endifmain function #include "IntContainer.h "
# incluir & ltvector & gt
# inclu
de & ltiostream & gt
# include & ltnumeric & gt
# include & ltfunctional& gt
Usar espacio de nombres stdint multiplicar(int x, int y){return símbolo()(T x, T y){ return x * y;}
};void main()
{
IntContainer & ltint & gtIC ;
IC . agregar(1);
IC . >IntContainer & ltint & gt* iterador end = IC end(); for(; first! = end; first++)
cout & lt& lt* first & lt& ltendl
Vector & ltint & gtvec
vec . push _ back(1);
vec . push _ back(2); & gt*iterador tmp = vec . comenzar();
tmp! = vec
tmp++)
{
cout & lt& lt*tmp<. & ltendl
} cout & lt& lt" _ _ _ _ _ _ _ _ _ _ _ _ _ " & lt& ltendl
cout & lt& ltaccumulate(vec.begin(), vec.end(), 1, multiplicado por & ltint & gt())& lt& ltendlddouble doubleArray[]={12, 13.4, 34, 5, 6.6};
cout & lt& ltaccumulation(& ampdoubleArray [0],&doubleArray[5],1,multiplicación<double>())<<endlvector<double>darray(10);
Suma parcial(&doubleArray[0], & ampdoubleArray[5], dArray.begin(), menos & ltdouble & gt());
for(vector & lt;doble & gt* iterador primero = Dar ray .begin();
¡Primero! = darray . end(); primero++ )
cout & lt& lt* primero & lt& ltendl
}