Resumen del conocimiento de la matriz de objetos dinámicos de C ++

Constructor predeterminado

    Primero, echemos un vistazo a cuál es el constructor predeterminado, como el siguiente código:

#include<iostream>
#include<math.h>
using namespace std;
class Point
{
    double x, y;
public:
    void print();
    Point(double a=0,double b=1){x=a;y=b;}  //默认构造函数
    Point(double a){x=1;y=1;} //构造函数
    Point(){} //默认构造函数

};
void Point::print()
{
    cout << x << " " << y << endl;
}

    Por lo tanto, puede saber que el constructor predeterminado generalmente se puede usar cuando el objeto se genera sin pasar parámetros. La situación correspondiente es:

Point point;   
Point *point=new Point;

    Los constructores no predeterminados deben pasar parámetros. Existen los siguientes puntos de conocimiento sobre el constructor predeterminado:

• El programa no define ningún constructor, hay un constructor predeterminado Point () {} y los valores de los miembros no se inicializan
• Hay dos formas de definir un constructor predeterminado, como se muestra en el código anterior, una es definir un constructor sin parámetros y la otra es definir un constructor con valores predeterminados para todos los parámetros.
• Nota: ¡Una clase solo puede tener un constructor predeterminado! En otras palabras, los dos métodos anteriores no pueden aparecer al mismo tiempo, generalmente elija Point (); esta forma de constructor predeterminado

Matriz dinámica con constructor predeterminado

    Echemos un vistazo si una clase tiene un constructor predeterminado, el siguiente código es para generar matrices estáticas y dinámicas:

#include<iostream>
#include<math.h>
using namespace std;
class Point
{
    double x, y;
public:
    void print();

};
void Point::print()
{
    cout << x << " " << y << endl;
}
int main() {
    //静态对象数组
    Point pp[5];      
    for (int i = 0; i<5; i++)
        pp[i].print();
    //动态对象数组
    Point *p = new Point[5]; //这里面5也可以是变量
    for (int i = 0; i<5; i++)
            p[i].print();
    //别忘记delete相应的空间
}

    Se puede ver que si una clase tiene un constructor predeterminado, entonces no hay necesidad de pasar parámetros al generarla, lo cual es mucho más conveniente.

Matriz dinámica sin constructor predeterminado

    Si una clase no tiene un constructor predeterminado, en este caso, debe pasar parámetros, como en el siguiente código:

#include<iostream>
#include<math.h>
using namespace std;
class Point
{
    double x, y;
public:
    Point(double a, double b);
    void print();
};
Point::Point(double a, double b)
{
    x = a;
    y = b;
}
void Point::print()
{
    cout << x << " " << y << endl;
}
int main()
{
    Point *p[5];//静态指针数组
    for (int i = 0; i < 5; i++) {
        p[i] = new Point(i, i);    //其中你可以用自己的方式来初始化对象，例如从键盘接收值等
    }
    for (int i = 0; i < 5; i++) {
        p[i]->print();
    }
    Point **pp = new Point *[5];  //动态指针数组，5也可以是变量
    for (int i = 0; i < 5; i++) {
        pp[i] = new Point(i, i);
    }
    for (int i = 0; i < 5; i++) {
        pp[i]->print();
    }
    //别忘了delete相应的空间
    return 0;
}

    La matriz de punteros estáticos se definen algunos Pointpunteros, mediante la nueva forma de hacer que cada puntero apunte al objeto. La matriz de punteros dinámicos asigna un espacio continuo de un tamaño fijo, cada tipo de elemento en él es Point *, y luego la primera dirección de este espacio continuo se asigna a pp, que es un puntero al tipo Point *.

Tenga en cuenta que es nuevo Punto * [5] en lugar de nuevo (Punto *) [5], el último compilador informará un error

nueva matriz multidimensional

int *p=new int[2];
int *p=new int[2][3];  //错误
int (*p)[3]=new int[2][3];  //正确
int (*p)[4][5]=new int[2][4][5]; //正确

    ¿Por qué está mal la segunda línea? De hecho, podemos entenderlo así:

• int (* p) [3] donde p es un puntero. Esto está fuera de toda duda. ¿A qué tipo de datos apunta este puntero? Cambiemos la forma de escribir, programando int [3] (* p), ¿es muy conciso y claro? El tipo al que apunta p es int [3].
• La primera dirección de las dos matrices de tipo int [3] devueltas por new int [2] [3] se asigna ap.
• De la misma manera, el tipo al que apunta p en la cuarta línea es int [4] [5], y new int [3] [4] [5] devuelve la primera dirección de 3 matrices de tipo int [4] [5], asignación Dar p.
• Para la primera línea, si la dirección inicial de p es 1000, asumiendo que int ocupa 4 bytes, luego de ejecutar p ++, la dirección de p es 1000 + 4, y en la tercera línea, si la dirección inicial de p es 1000, después de realizar p ++, el valor de p es 1000 + 4 * 3, y así sucesivamente, el valor de p después de p ++ en la cuarta línea es 1000 + 4 * 4 * 5.