Una clase es un modelo y cuando creamos una instancia de esta clase, es el objeto en sí.
Puede haber variables y funciones dentro de un objeto, y la estructura generalmente se compone de varias variables. Los objetos tienen muchas similitudes con las estructuras, pero los objetos también pueden tener sus propias funciones.
Una clase se compone de variables y funciones, qué variables usará el objeto para almacenar información y qué funciones llamar para completar la operación, por lo que es habitual que las variables de la clase se conviertan en atributos y las funciones en métodos.
OOP (proceso de programación orientado a objetos):
El primer paso: crear una clase (cada clase tiene un nombre como una variable, la primera letra del nombre de la clase suele estar en mayúscula)
El solucionador de alcance "::" le dice al compilador dónde existe este método, oa qué clase pertenece.
A lo que std :: cout se refiere es cout definido por std, y el tipo de datos std :: string es en realidad un objeto.
class Car
{
public ://(public这个关键词实际上就是作用域的问题)
std::string color;
std string eigine;
float gas_tank;
unsigned int Wheel;
//方法的声明(写在类里面)
void fill_Tank(float liter);//只有一个参数，不需要返回值
void running(void);//不需要返回类型，不需要参数
//方法的定义通常安排在类声明的后面
};//可以直接在这个后边定义类的对象Car（但是一般呢不这样用，将声明和定义是分开的）。
//方法的定义通常安排在类声明的后面
void Car::fill_Tank(float liter)//::是作用域解析符（是在说fill_Tank这个函数是在Car这个类里边的）
{
gas_tank += liter;
}
int main()
{
Car mycar;//使用Car这个类定义一个变量mycar（在创建类的对象时，也可以像结构那样直接在大括号后边进行定义），一个具体实例。拥有方法和属性
mycar.gas_tank=85；
return 0;
}PD: Podemos almacenar la declaración de la clase y la definición de la función de la clase en dos archivos diferentes, la declaración en el archivo de encabezado .h y la definición en el archivo .cpp correspondiente.
C ++ le permite declarar una constante en una clase, pero no permite que se asigne.
La asignación de un objeto a otro objeto del mismo tipo hará que el atributo con el mismo nombre tenga el mismo valor automáticamente.
class Car
{
public:
const float TANKSIZE=85;//这样会出错。
}
//绕开这一限制的方法就是创建一个静态常量
class Car
{
public:
static const float TANKSIZE=85;//这样会出错。
}；
Car car1,car2;
car2=car1;//把一个对象赋值给另一个同类的对象将会自动使同名的的属性有同样的值。Resumen: Los pasos más básicos para desarrollar un programa:
(1) Defina una clase con atributos (variables) y métodos (funciones). (modelo)
(2) Cree una variable para esta clase. (lograr)
-------------------------Extensión
Constructor:
1. La principal diferencia entre el constructor y el método habitual:
- El nombre del constructor debe ser el mismo que el nombre de la clase en la que se encuentra.
- Cuando el sistema crea una instancia de una determinada clase, llamará automáticamente al constructor de esta clase tan pronto como sea posible.
- El constructor nunca devolverá ningún valor.
2. Para crear un constructor, debe agregar su declaración a la clase:
class Car
{
Car(void);
}3. Tenga en cuenta que las mayúsculas son coherentes con el nombre de la clase. Después del final de la declaración, comience a definir el propio constructor:
Car::Car(void)//因为构造器默认不会有任何返回值，所以我们不用写为 void Car::Car(void)
{
color="white";
engine="V8";
wheel=4;
gas_tank=FULL_GAS;
}4. La función del constructor es inicializarlo
class Car
{
std::string color;
std::string enigen;
unsigned int gas_tank;
unsigned int wheel;
Car(void);
void set color(std string col);
void set enigen(std string eng);
void set wheel(unsigned int whe);
void fill tank(int liter);
int running(void);
void warning(void);
}
Car::Car(void)
{
color="white";
}5. Construye una matriz de objetos
Las matrices pueden ser de cualquier tipo de datos y, por supuesto, también contienen objetos.
Car mycar[10];//Car是类名，后边是一个数组
//调用的语法：
Mycar[x].running;//x表示给定数组元素的下标6. Tenga en cuenta que cada clase tiene al menos un constructor. Si no define un constructor en la clase, el compilador usará la siguiente sintaxis para definir uno por usted:
ClassName::ClassName(){}Incinerador de basuras:
Al crear un objeto, el sistema llama automáticamente a un método especial, el constructor.
Al destruir un objeto, el sistema también debería llamar a otro método especial para lograr el efecto correspondiente, a saber, el destructor. (En términos generales, el constructor se usa para completar el trabajo de pre-inicialización y preparación (solicitud de memoria), y el destructor se usa para completar el trabajo de limpieza necesario (borrar memoria))
1. El destructor tiene el mismo nombre que el constructor / clase, pero con un prefijo de tilde "~". El destructor nunca devolverá ningún valor. El destructor no toma parámetros, por lo que el formato de declaración del destructor es siempre ~ ClassName ();
class Car(void)
{
Car();
~Car();
}
//析构器是不带参数的，所以析构器的声明格式永远是
~ClassName();En el ejemplo anterior, el destructor es opcional, (debido a que en el ejemplo no involucró la aplicación de memoria y la aplicación de memoria dinámica, solo solicite algunas variables, y las variables están en Esta función será devuelta automáticamente por el mecanismo de pila cuando el objeto termine, y no necesitamos ocuparnos de él; si usamos alguna memoria dinámica solicitada por este nuevo, debemos liberarla en el destructor; o podemos abrir una El archivo también solicita memoria para él. Por ejemplo, debe haber un closefile correspondiente al openfile, luego debemos escribirlo en el constructor y destructor respectivamente), pero en clases más complejas, el destructor suele ser muy importante. (Puede causar una pérdida de memoria. Es decir, solicitó una parte de la memoria y no la usó, o después de llamar a esta parte de la memoria, su clase se elimina, pero su parte de la memoria no se libera, entonces estará en el espacio de la memoria. Guárdelo en el archivo y mantenga esta dirección.Cuando acceda accidentalmente a esta dirección, parecerá que la memoria no se puede leer y aparecerá un cuadro de diálogo de error); por ejemplo, si el constructor de una determinada clase solicita una pieza de memoria, debemos Libera esta memoria en el destructor.
#include<iostream>
#include<string>
#include<fetream>
class StoreQuote
{
publis:
std::string quote,sperker;
std::ofstream fileOutput;
StoreQuote();//构造器
~StoreQuote();//析构器
void inputQuote();
void inputSpeaker();
bool write();
};//类的声明
StoreQuote::StoreQuote()
{
fileoutput.open("test.txt",std::ios::app);//类.方法()打开一个文件,app表示追加的形式打开
}
StoreQuote::~StoreQuote()
{
fileOutput.close();//析构器里边对它进行关闭
}
void StoreQuote::inputQuote()
{
std::getline(std::cin,quote);//写入这句话，把他写进quote这个字符串里边
}
void StoreQuote::inputSpeaker()
{
std::getline(std::cin,speaker);//写入作者，把他写入speaker这个字符串里边
}
bool StoreQuote::write()//把刚才的两个给写入文件里边
{
if(fileOutput.is_open())
{
fileOutput<<qupte<<"i"<<speaker<<"\n";
return true;
}
else
{
return false;
}
}
int main()
{
StoreQuote quote;
std::cout<<"请输入一句话：\n";
quote.inputQuote();//调用这个函数
std::cout<<"请输入作者：\n"；
quote.inputSpeaker();
if(quote.write())//判断是否成功的写入文件
{
std::cout<<"成功写入文件"；
}
else
{
std::cout<<"写入文件失败"：
return 1;
}
return 0;//main函数的默认返回值
}