Red de conocimiento informático - Aprendizaje de código fuente - Código fuente máximo

Código fuente máximo

Archivo de encabezado 1: # incluye plantilla " int contenedor . h "

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

}