C ++ no admite la abstracción abstracta de matrices o la operación de toda la matriz. A veces queremos operar en toda la matriz. Por ejemplo, asignar una matriz a otra matriz para comparar las dos matrices o comparar el tamaño de la matriz. No podemos usar el operador de asignación para copiar una matriz a otra para dos matrices.
int array0 [10], array1 [10];
array0 = array1; // error El
tipo de matriz en sí no tiene conciencia de sí mismo y no conoce su longitud. Además, debemos registrar esta información de la matriz en sí.
La relación entre la matriz y el puntero:
int ia [] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
ia; El identificador de matriz representa la dirección del primer elemento de la matriz y su tipo es un puntero al tipo de elemento de matriz.
ia; Equivalente & ia [0];
* (ia + 1); Equivalente ia [1];
Creación de objetos
* El primero es definir directamente una instancia del objeto de clase:
CGoods Car;
esta definición crea una clase CGoods El objeto Car, al mismo tiempo, asigna su propio bloque de almacenamiento para almacenar datos y funciones miembro (códigos) que operan en estos datos. Al igual que con las definiciones de variables, un objeto solo es válido en el dominio en el que está definido.
* El segundo método es crear dinámicamente objetos de clase.
La asignación de memoria dinámica (Dynamic Memory Allocation) puede resolver los problemas que la compilación estática no puede resolver, como el uso de matrices.
C / C ++ define 4 rangos de memoria: 1), área de código, 2), área de variable global y variable estática, 3), área de variable local es el área de pila, 4), área de almacenamiento dinámico, es decir, el área de almacenamiento dinámico o Área de almacenamiento gratuito (tienda gratuita).
Asignación estática y asignación dinámica:
generalmente define variables (u objetos), el compilador puede conocer el tamaño del espacio de memoria requerido de acuerdo con el tipo de variables (u objetos) en el momento de la compilación, de modo que el sistema les asigne cierto almacenamiento cuando sea apropiado Espacio. Este tipo de asignación de memoria se denomina asignación de almacenamiento estático.
Algunos objetos de operación solo se pueden determinar cuando el programa se está ejecutando, por lo que no pueden reservarles espacio de almacenamiento para la compilación. Solo cuando el programa se está ejecutando, el sistema asigna memoria según los requisitos. Este método se denomina asignación de almacenamiento dinámico.
Todas las asignaciones de almacenamiento dinámico se realizan en el área de almacenamiento dinámico. Cuando el programa se ejecuta en una variable u objeto asignado dinámicamente, debe aplicar al sistema para obtener un bloque de espacio de almacenamiento del tamaño requerido para almacenar la variable u objeto. Cuando la variable u objeto ya no se usa, es decir, al final de su vida útil, el espacio de almacenamiento que ocupa debe liberarse explícitamente para que el sistema pueda reasignar el espacio de almacenamiento dinámico y reutilizar recursos limitados.
Formato de asignación dinámica:
nombre de la variable del puntero = nuevo nombre de tipo (tipo de inicialización);
eliminar el nombre del puntero;
por ejemplo:
int * pi = new int (0);
eliminar pi; // Tenga en cuenta que se libera el espacio de memoria de destino al que apunta pi, pero pi El puntero en sí no se revoca, y el espacio de memoria ocupado por el puntero no se libera.
Explicación: El
* operador nuevo devuelve un puntero a una variable (objeto) del tipo asignado. Las variables u objetos creados se operan indirectamente a través del puntero, y el objeto creado dinámicamente no tiene nombre.
* Generalmente define variables y objetos con identificadores, objetos con nombre y objetos sin nombre con nombre dinámico (tenga en cuenta la diferencia con los objetos temporales en el área de la pila, los dos son completamente diferentes: diferentes vidas, diferentes métodos de operación, temporales Las variables son transparentes para los programadores).
* El área de almacenamiento dinámico no se inicializará automáticamente (incluido el borrado) durante la asignación, y debe inicializarse explícitamente con un inicializador.
* La secuencia de operación de la nueva expresión es la siguiente: asigne el objeto del montón y luego inicialice el objeto con el valor entre paréntesis.
Basado en el diseño de objetos para
lograr la abstracción de la matriz,
1. La implementación de la clase de matriz tiene una autoconciencia incorporada, en primer lugar, conoce su tamaño.
2. La clase de matriz admite la asignación entre matrices y operaciones de comparación entre dos matrices para igualdad y desigualdad.
3. La clase de matriz debe admitir las siguientes operaciones de consulta sobre los valores contenidos en ella: ¿Cuál es el valor mínimo en la matriz? ¿Cuál es el valor máximo? ¿Es el índice de la primera posición en la matriz si existe?
4. La clase de matriz admite la clasificación automática. Para facilitar la discusión, se supone que hay un grupo de usuarios que piensan que la función de clasificación de soporte de matriz es muy importante, pero otros no lo dan por sentado. Además de admitir las operaciones de matriz, la matriz misma debe ser compatible.
5. Puede especificar la longitud para crear una matriz. Este valor no necesita ser conocido en tiempo de compilación.
6. Capacidad para inicializar una matriz con un conjunto de valores.
7. Se puede acceder a un solo elemento de la matriz a través de un índice. Para facilitar la discusión, suponga que el usuario requiere con fuerza el operador de subíndice de matriz para lograr esta función.
8. La capacidad de interceptar y señalar valores de índice incorrectos supone que creemos que esto es necesario, por lo que no tenemos idea de preguntarle al usuario. Creemos que esto es imprescindible para una matriz bien diseñada. Nuestras conversaciones con usuarios potenciales han causado un gran calor.
IntArray.h
clase IntArray
{
private:
int _size; // Tamaño de matriz
int * p; // Puntero de matriz
public:
IntArray (int array_size);
IntArray (int * array, int array_size);
IntArray (IntArray & arr); // Copiar constructor
~ IntArray () ;
void sort (); // sort
int find (int value); // find
int max (); // elemento máximo
int min (); // elemento mínimo
int size (); // tamaño de matriz
void display () ;
};
IntArray.cpp
#include <iostream> // Introducción del archivo de flujo io
#include "IntArray.h"
utilizando el espacio de nombres std;
/ ********************* ************************************************** * /
/ * Constructor El
elemento de matriz predeterminado se inicializa a 0
* /
/ ************************************************* *********************** /
IntArray :: IntArray (int array_size)
{
_size = array_size;
p = new int [array_size];
for (int i = 0; i <array_size; i ++)
{
p [i] = 0;
}
}
/ ******************************* ***************************************** /
/ * El constructor se
inicializa con una matriz Otra matriz
* /
/ ******************************************** **************************** /
IntArray :: IntArray (int * array, int array_size)
{
_size = array_size;
p = new int [array_size];
for (int i = 0; i <array_size; i ++)
{
p [i] = array [i];
}
}
/ ************************************************ ************************ /
/ * Calcular el valor máximo de la matriz * /
/ **************** ************************************************** ****** /
int IntArray :: max ()
{
int max = -1;
for (int i = 0; i <_size; i ++)
{
if (p [i]> max) {
max = p [i ];
}
}
return max;
}
/ ***************************************** ******************************* /
/ * Calcular el valor mínimo de la matriz * /
/ ********* ************************************************** ************* /
int IntArray :: min ()
{
int min = 10000;
for (int i = 0; i <_size; i ++)
{
if (p [i] <min) {
min = p [i];
}
}
return min;
}
/ ************************** ********************************************** /
/ * Buscar Especifique el elemento, devuelva la posición en la matriz * /
/ ************************************** ********************************** /
int IntArray :: find (int value)
{
int index = -1 ;
for (int i = 0; i <_size; i ++)
{
if (p [i] == value) {
index = i;
}
}
return index;
}
/ ************* ************************************************** ********* /
/ * Devuelve el tamaño de la matriz * /
/ ******************************** **************************************** /
int IntArray :: size ()
{
return _size;
}
/ ************************************* *********************************** /
/ * Mostrar el valor en el elemento de matriz * /
/ *** ************************************************** ******************* /
void IntArray :: display ()
{
for (int i = 0; i <_size; i ++)
{
cout << p [i] < <"";
}
cout << endl;
}
/ ****************************************** ********************************** /
/ * Ordenar la matriz, ascendente o descendente * /
/ *** ************************************************** ******************* /
void IntArray :: sort ()
{
}
/ ************************************************* *********************** /
/ * Destructor, espacio libre en memoria * /
/ ************** ************************************************** ******** /
IntArray :: ~ IntArray ()
{
delete p;
}
/ **************************** ************************************************ /
/ * Función de llamada * /
/ *********************************************** ************************* /
int main (nulo)
{
int intA [] = {10,2,4,6,7,98, 32,4};
IntArray intArr (intA, 8);
cout << "tamaño:" << intArr.size () << endl;
cout << "max:" << intArr.max () << endl;
cout << "min:" << intArr.min () << endl;
cout << "find:" << intArr.find (98) << endl;
intArr.display ();
intArr. ~ IntArray ();
}
Programación genérica (programación genérica) La
clase IntArray proporciona un tipo alternativo útil para tipos de matriz enteros predefinidos. Si el usuario desea utilizar una
clave de matriz de tipo double o string Se introduce la plantilla de la palabra. Los parámetros de la plantilla están encerrados entre paréntesis angulares <>
template <class elemType>
class Array {
public:
Array (int size);
Array (elemType * array, int array_size);
virtual elemType min ();
virtual elemType max ( );
Privado:
int _size;
elemType * ia;
};
Más tarde, cuando creemos una instancia de un tipo específico, como una matriz Array de tipo int double o string, puede usar estas tres instancias directamente en el programa.
Llame:
const int array_size = 4;
// elemType se convierte en int
Array <int> ia (array_size);
// elemType se convierte en
Array doble <double> da (array_size);
// elemType se convierte en char
Array <char> ca (array_size);
¿qué sucede con las funciones miembro de la plantilla de clase? No todas las funciones miembro pueden ser automáticamente Se crea una instancia con la instancia de la plantilla de clase. Solo se crean instancias de las funciones miembro que realmente utiliza el programa. Esto generalmente ocurre en una etapa independiente en el proceso de generación del programa.
Objetos C ++, matrices, diseño basado en objetos.
Supongo que te gusta
Origin www.cnblogs.com/zhenhua1618/p/12729762.html
Recomendado
Clasificación