1. Herencia de clases
class Shape{
};
class Circle : public Shape{
};gramática:
class B : public A{}
B hereda de A, la clase A es la clase principal y B es una clase derivada (subclase).
Cuando B hereda de A, hereda automáticamente todos los miembros públicos de la clase principal y no puede heredar los privados.
Nuevo modificador: protected
(1) No se puede acceder a este miembro externamente, como private
(2) Este miembro puede ser heredado por subclases, como public
Describa la relación entre la clase principal y la subclase en la memoria: la memoria de la clase principal está al frente y las
variables miembro privadas de la clase principal también aparecerán en la memoria, pero el compilador restringe el acceso
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
class Shape{
public:
char name[16];
char size[16];
public:
void Show()
{
printf("%s ,%s \n",name,size);
}
protected:
int abc = 10;
};
class Circle : public Shape
{
//Circle自己的一些函数。
public:
void Play()
{
printf("abc = %d\n",abc);
}
};
int main()
{
Circle c;
strcpy(c.name,"xigua");
strcpy(c.size,"big");
c.Show();
c.Play();
return 0;
}
2. Herencia virtual
1. Reescritura de funciones
class Parent{
public:
void test()
{
printf("Parent.....\n");
}
};
class Child:public Parent
{
public:
void test()
{
Parent::test();
printf("Child.....\n");
}
};
3. El puntero de la clase padre puede apuntar al objeto de la subclase
class Parent{
public:
int a ;
};
class Child:public Parent
{
public:
int b;
};
int main()
{
Child c;
c.a = 10;
c.b = 20;
Parent* p = &c;
printf("%d \n",p->a);
return 0;
}4. La introducción de la pregunta:
Padre* p = nuevo Hijo();
p->prueba();
¿A quién apunta la prueba?
class Parent{
public:
void test()
{
printf("Parent.....\n");
}
};
class Child:public Parent
{
public:
void test()
{
printf("Child.....\n");
}
};
int main()
{
Child ch;
Parent* p = &ch;
p->test();
return 0;
}
Cuando una función miembro debe ser anulada por una subclase, la clase principal debe declararla como virtual.
Si la función de la clase principal se define como virtual, llamará a la función de la subclase.
class Parent{
public:
virtual void test()
{
printf("Parent.....\n");
}
};
class Child:public Parent
{
public:
void test()
{
printf("Child.....\n");
}
};
3. Hablemos de construcción y destrucción
Al crear un objeto de subclase, al
construir, primero llame al constructor de la clase principal y luego llame al constructor de la subclase
Al destruir, llame primero al destructor de la subclase y luego llame al padre constructor de clases de
Si la clase principal tiene varios constructores, uno de ellos se puede llamar explícitamente.
Si no hay una llamada explícita, se llama al constructor predeterminado de forma predeterminada.
que es un constructor
Visión: el diseño y la fabricación de cualquier cosa tiene la visión y la expectativa antes de que naciera. La buena expectativa del constructor es inicializar el objeto al comienzo de la creación del objeto. Durante la inicialización, hay llamadas a funciones y algunas funciones deben ser completado. .
Las cosas de procedimiento son cosas precisas y estandarizadas, por lo que sus nombres a menudo tienen significados precisos. La mayor parte del significado de nombrar es para un simple apodo. La invención de cosas grandes y significativas radica en el portar Hay muchos significados. El mismo nombre es solo un nombre en clave que puede identificarlo de un grupo determinado. También puede incorporar buenas expectativas para la vida en el nombre al nombrarlo, al igual que muchos padres nombran a sus hijos. Con la expectativa de la vida pequeña, también trae la percepción de los padres y bendición de la vida como ser humano.
El nombre del constructor es el mismo que el nombre de la clase definida.
Ya que es una categoría que pertenece a toda la categoría, cada uno de nosotros nace diferente, y cada individuo tiene sus propias características únicas, algunas son hermosas para asfixiar, algunas son tan profundas que son adictivas y algunas tan tiernas que duelen. Innumerables diferencias forman un universo sin fin como las vastas estrellas. No somos diferentes por una pequeña diferencia, pero cada pedacito de cada uno de nuestros pequeños mundos es diferente.
El constructor está subordinado a la función, pero es una función que no devuelve un valor.
uno e infinito
Muchas cosas conllevan innumerables ensoñaciones y conjeturas desde el comienzo de su nacimiento, pero los humanos inteligentes pueden construir mucho en sus cerebros, ya sea infinito o 1, pueden ser utilizados.Al enfrentarse al vasto mar de estrellas, el corazón humano. está lleno de conmoción y grandeza. Cuando te enfrentas a las necesidades diarias, arroz, aceite y sal, también puedes cocinar de manera realista.
Las personas son diferentes debido a la unidad y la infinidad del número. La estrella solitaria es diferente de la estrella del mar. Los innumerables grilletes entre la estrella del mar en sí tendrán un ensueño mucho más hermoso que la estrella solitaria. Pegasus meteorito, agosto león, tiempo y viajes espaciales, y estrellas del mar.
Puede haber varios constructores con parámetros vacíos.
Racionalidad entre el feed y la tabla de contenido
La disposición de los asuntos en el mundo mismo es para realizar sus propios deberes, y cada uno es libre y sin restricciones en su propio pequeño mundo.Si hay ambición, las personas mismas también pueden trabajar desde abajo. Hay demasiadas cosas triviales en la vida de los pequeños seres humanos, por lo que el resumen del catálogo es para recordarnos que volvamos al estándar, y otra es la sistematicidad de los cambios cuantitativos que conducen a cambios cualitativos.
Todas las clases tienen constructores:
Si no se define ningún constructor, el compilador de C++ generará un constructor predeterminado sin parámetros y con un cuerpo de función vacío.
Cuando se define, el constructor sin argumentos se llama automáticamente
Cuando se hereda una clase, el destructor debe considerarse virtual
:
Parent * p = &ch;
delete p;
puede hacer que el programa se bloquee
class Parent{
public:
Parent()
{
printf("Parent: 创建\n");
a = b = 0;
}
Parent(int x,int y)
{
printf("Parent: 创建 参数：%d, %d\n",x,y);
a = x;
b = y;
}
~Parent()
{
printf("Parent: 销毁\n");
}
private:
int a,b;
};
class Child:public Parent
{
public:
Child():Parent(1,2)//显式的调用
{
printf("Child: 创建\n");
}
~Child()
{
printf("Child: 销毁\n");
}
};
int main()
{
Parent* p= new Child();
delete p;
return 0;
}
**//改成virtual ~Parent**
Cuatro Herencia múltiple
Padre, Madre representa dos clases
niño de clase: padre público, madre pública { };
El problema de la herencia múltiple: cuando varias clases principales tienen las mismas variables, se producirán errores, por lo que habrá menos lugares para usarlas y las funciones virtuales puras estarán involucradas más adelante.