Varios peces utilizados para resolver la terminología que Python no entendía en detalle antes, a menudo ver Chang Xin (
Definición:
La definición se refiere a la asignación de espacio de memoria a una entidad para su uso en el programa. En C++ y Python, esta entidad puede ser una variable, función o clase. En C++, una definición suele ser lo que implementa una entidad después de una declaración.
Por ejemplo f(int a, int b)
// 定义整数变量x
int x;
// 定义函数add，计算两个整数的和
int add(int a, int b) {
return a + b;
}
# 定义整数变量x
x = 10
# 定义函数add，计算两个整数的和
def add(a, b):
return a + b
Declaración:
La declaración se refiere a declarar la existencia de entidades en el programa, pero no asignarles espacio de memoria. En C++ y Python, esto permite que el compilador o intérprete sepa con anticipación el nombre y el tipo de la entidad antes de que se use.
Por ejemplo f(int,int)
// 声明整数变量y
extern int y;
// 声明函数add，用于计算两个整数的和
int add(int a, int b);
Python no requiere una declaración explícita
Instancia:
Una instancia es un objeto concreto de una clase. En C++ y Python, la creación de instancias consiste en crear una instancia de una clase y asignar espacio en la memoria para almacenar sus atributos y métodos.
// 定义一个简单的类Person
class Person {
public:
int age;
};
// 创建Person类的实例p1
Person p1;
p1.age = 30; // 设置实例p1的age属性为30
# 定义一个简单的类Person
class Person:
pass
# 创建Person类的实例p1
p1 = Person()
p1.age = 30 # 设置实例p1的age属性为30
Llama llama):
La invocación se refiere al proceso de ejecutar una función o método. En C++ y Python, llama a una función o método usando su nombre y los parámetros apropiados.
Por ejemplo f(a, b)
// 定义函数multiply，计算两个整数的乘积
int multiply(int a, int b) {
return a * b;
}
// 调用函数multiply，并将结果存储在变量result中
int result = multiply(5, 3);
# 定义函数multiply，计算两个整数的乘积
def multiply(a, b):
return a * b
# 调用函数multiply，并将结果存储在变量result中
result = multiply(5, 3)
Herencia:
La herencia es un concepto importante en la programación orientada a objetos que permite que una clase (llamada subclase o clase derivada) herede las propiedades y métodos de otra clase (llamada clase padre o base).
// 定义一个基类Animal
class Animal {
public:
void makeSound() {
cout << "Some generic sound" << endl;
}
};
// 定义一个派生类Dog，继承自Animal
class Dog : public Animal {
public:
void makeSound() {
cout << "Woof! Woof!" << endl;
}
};
// 创建Dog类的实例d1，并调用其makeSound方法
Dog d1;
d1.makeSound(); // 输出：Woof! Woof!
# 定义一个基类Animal
class Animal:
def makeSound(self):
print("Some generic sound")
# 定义一个派生类Dog，继承自Animal
class Dog(Animal):
def makeSound(self):
print("Woof! Woof!")
# 创建Dog类的实例d1，并调用其makeSound方法
d1 = Dog()
d1.makeSound() # 输出：Woof! Woof!
Animal es el elemento padre de Dog
Encapsulación:
La encapsulación es un concepto de programación orientada a objetos que encapsula datos y código en una unidad y oculta los detalles de implementación del exterior. Esto garantiza la seguridad de los datos y simplifica el uso del código.
class Person {
private:
int age;
public:
void setAge(int newAge) {
age = newAge;
}
int getAge() {
return age;
}
};
// 创建Person类的实例p1
Person p1;
p1.setAge(25);
int currentAge = p1.getAge(); // 通过公共方法访问私有属性age
En Python, no existe un control de acceso estricto, pero la encapsulación se logra mediante una convención que define los atributos como privados y proporciona métodos públicos.
Embalaje:
El empaquetado se refiere a la organización de módulos y recursos relacionados para facilitar su distribución, instalación y uso. En C++, el empaquetado generalmente se refiere a agrupar clases relacionadas, archivos de encabezado y archivos fuente para formar un archivo de biblioteca. En Python, el empaquetado generalmente se refiere a la organización de módulos en paquetes para una fácil distribución e instalación.
Ejemplo de empaquetado en C++: Cree un archivo de biblioteca utilizando el SDK de C++ (Kit de desarrollo de software).
Ejemplo de empaquetado en Python: organice los módulos relacionados en una carpeta e incluya un archivo __init__.py en la carpeta, convirtiéndolo en un paquete.
Constructor:
Los constructores son métodos especiales que se llaman automáticamente cuando se crea una instancia de una clase para inicializar las propiedades y el estado del objeto. En C++, el nombre del constructor es el mismo que el nombre de la clase, y en Python, el método __init__ se usa como constructor.
class Person {
public:
int age;
// 构造函数
Person() {
age = 0;
}
Person(int initialAge) {
age = initialAge;
}
};
// 创建Person类的实例p1，并调用带参数的构造函数
Person p1(30);
class Person:
def __init__(self):
self.age = 0
def __init__(self, initialAge):
self.age = initialAge
# 创建Person类的实例p1，并调用带参数的构造函数
p1 = Person(30)
:: (Operador de Resolución de Alcance)：
En C++, :: es el operador de resolución de ámbito, que se utiliza para especificar la búsqueda de un identificador (como una variable miembro o un método de una clase) en un ámbito específico. También se utiliza para acceder a elementos en un espacio de nombres.
No hay un operador :: en Python porque Python usa un punto (.) como operador de resolución de alcance.
Lanzar (Señal) y emitir:
En Qt, una señal es un mecanismo para enviar mensajes entre objetos. Las señales son funciones miembro especiales que se pueden emitir con la palabra clave emit cuando ocurre un evento específico. Otros objetos pueden conectarse a estas señales y ejecutar la función de ranura asociada cuando se emite la señal.
class MyButton : public QPushButton {
Q_OBJECT
signals:
void clickedWithCount(int count);
public slots:
void onButtonClick() {
static int clickCount = 0;
clickCount++;
emit clickedWithCount(clickCount);
}
};
// 创建MyButton的实例，并连接到槽函数
MyButton button;
QObject::connect(&button, &MyButton::clickedWithCount, [](int count) {
cout << "Button clicked " << count << " times" << endl;
});
button.click(); // 触发信号，槽函数输出 "Button clicked 1 times"
button.click(); // 触发信号，槽函数输出 "Button clicked 2 times"
En Python, no hay un mecanismo de señal y ranura explícito, pero puede usar el módulo de señal y ranura en Qt para Python para lograr una funcionalidad similar.
Los mensajes y las ranuras son un mecanismo en Qt para la comunicación entre objetos. Un objeto emite una señal (información), y otros objetos están conectados a la función de ranura de la señal. Cuando se emite la señal, se ejecutará la función de ranura.
En el ejemplo anterior de Qt, clickedWithCount es una señal y onButtonClick es una ranura.
SDK (Kit de desarrollo de software):
SDK, abreviatura de Software Development Kit, es una colección para desarrollar aplicaciones, que generalmente incluye bibliotecas, documentación de API, código de muestra y herramientas. Un SDK puede ayudar a los desarrolladores a usar más fácilmente la funcionalidad de una plataforma o marco específico.
En C++ y Qt, Qt SDK es un conjunto de herramientas para desarrollar aplicaciones multiplataforma, incluida la biblioteca Qt, Qt Creator IDE, documentación de Qt, etc.
En Python, el SDK de Python (también conocido como Biblioteca estándar de Python) es la biblioteca central del lenguaje Python, que proporciona muchos módulos y funciones integrados para realizar diversas tareas.
Dinámico (Dynamic) y estático (Static):
Dinámico y estático se utilizan a menudo para describir las propiedades de un lenguaje o sistema de tipos.
Lenguaje dinámico (como Python): el tipo de variable se determina en tiempo de ejecución, no necesita declarar explícitamente el tipo, tiene mayor flexibilidad, pero puede causar errores de tiempo de ejecución en algunos casos.
Lenguaje estático (como C++): el tipo de variable se determina en el momento de la compilación y el tipo debe declararse explícitamente, lo que es más estricto y seguro para los tipos, pero puede generar una escritura de código más engorrosa.
En C++, las variables pueden tener una duración de almacenamiento estática o dinámica, que está relacionada con la duración y el alcance de la variable. En Python, las variables se escriben dinámicamente y el intérprete infiere el tipo en tiempo de ejecución.
modificador
Los modificadores se utilizan para controlar el acceso y los atributos de los miembros de una clase. Ayudan a implementar conceptos de programación orientada a objetos, como encapsulación, herencia y polimorfismo.
público:
En C++ y Qt, el modificador público se usa para especificar el acceso público a los miembros de la clase. Se puede acceder a los miembros públicos dentro y fuera de la clase, incluidos los objetos de la clase y otras clases.
Ejemplo en C++:
class MyClass {
public:
int publicVar;
void publicMethod() {
// code here
}
};
Ejemplo en Qt:
class MyClass : public QObject {
Q_OBJECT
public:
int publicVar;
void publicMethod() {
// code here
}
signals:
void mySignal();
};
En Python, los miembros de una clase son públicos de forma predeterminada sin una palabra clave pública explícita.
protegido:
En C++ y Qt, el modificador protected se usa para especificar el acceso protegido a los miembros de la clase. Se puede acceder a los miembros protegidos dentro de la clase y en las clases derivadas, pero no fuera de la clase.
Ejemplo en C++:
class MyClass {
protected:
int protectedVar;
void protectedMethod() {
// code here
}
};
En Qt, debido a los requisitos especiales del mecanismo de señal y ranura, la señal en Qt debe definirse en la parte protegida o pública.
En Python, no hay una palabra clave protegida explícita, pero las propiedades o los métodos se pueden proteger de forma implícita al preceder el nombre de la propiedad o del método con un guión bajo.
privado:
En C++ y Qt, el modificador privado se usa para especificar el acceso privado a los miembros de la clase. Solo se puede acceder a los miembros privados dentro de la clase y no se puede acceder directamente fuera de la clase y en las clases derivadas.
Ejemplo en C++:
class MyClass {
private:
int privateVar;
void privateMethod() {
// code here
}
};
Ejemplo en Qt:
class MyClass : public QObject {
Q_OBJECT
private:
int privateVar;
void privateMethod() {
// code here
}
};
En Python, se logra un efecto similar al prefijar la propiedad o el nombre del método con dos guiones bajos, es decir, hacer que la propiedad o el método sean privados.
señal y ranura:
En Qt, la señal es una función miembro especial que se usa para transmitir mensajes y se usa para implementar el mecanismo de información y ranura. Solo declara, no define, porque es manejado por el sistema de metaobjetos de Qt. La señal se usa para emitir notificaciones y la ranura es una función de ranura que se usa para recibir notificaciones.
Ejemplo en C++ y Qt:
class MyClass : public QObject {
Q_OBJECT
signals:
void mySignal();
public slots:
void mySlot() {
// code here
}
};
En Python, no hay señal directa ni mecanismo de ranura. Sin embargo, se puede usar un mecanismo similar de señal y ranura usando una biblioteca Qt para Python como PyQt o PySide.
———————————————————
Hay ejemplos de llamadas de declaración de definición:
#include <iostream>
// 函数声明，只需写参数类型
int add(int, int);
// 函数定义，实现两个整数相加的功能
int add(int a, int b) {
return a + b;
}
int main() {
a = 5;
b = 3;
// 函数调用，传递参数值并获得返回结果
int result = add(a, b);
// 输出结果
std::cout << "Result: " << result << std::endl;
return 0;
}
puntero, dirección
El puntero es un concepto importante relacionado con la dirección de memoria y el tipo de datos. Expliquemos los siguientes términos paso a paso:
Puntero:
Un puntero es una variable cuyo valor es una dirección de memoria, es decir, la ubicación de un dato en la memoria de la computadora. Los punteros pueden apuntar a variables de cualquier tipo de datos, incluidos tipos de datos básicos, matrices, estructuras, clases, etc.
Obtener dirección (&):
en C++, utilice el operador & para obtener la dirección de memoria de la variable, es decir, el puntero de la variable. Por ejemplo, para la variable a, &a representa la dirección de memoria de a.
int a = 10;
int* ptr = &a; // 获取变量a的地址，并将其赋值给指针ptr
*a：
在C++中，*号用于两个不同的情况：
a. 定义指针变量：例如，int* ptr; 定义了一个指向整数的指针变量ptr。
b. 解引用操作：例如，*ptr 表示获取指针ptr指向地址的值。这个过程称为解引用，它允许我们访问指针指向地址的数据。
int a = 10;
int* ptr = &a; // 定义指向整数的指针ptr，并将其指向a的地址
int value = *ptr; // 解引用ptr，获取a的值，value现在为10
&a：
&a表示变量a的地址，它是一个指向a的指针。
指针的使用：
指针通常用于动态内存分配、函数参数传递、数组操作等。它们使得我们能够在程序运行时管理内存和操作数据。
int main() {
int a = 10;
int* ptr = &a; // ptr指向变量a的地址
*ptr = 20; // 解引用ptr并将新的值20赋给a
std::cout << "a: " << a << std::endl; // 输出20，因为通过ptr修改了a的值
return 0;
}
El ejemplo anterior define un puntero ptr a un número entero, que apunta a la dirección de la variable a. Desreferenciando el puntero ptr, podemos modificar el valor de a. Modificar el valor al que apunta el puntero también modifica la variable a la que apunta el puntero.