La esencia de la llamada sobrecarga de funciones es definir una función con diferentes parámetros pero con el mismo propósito y el mismo nombre . (Identidades múltiples) (tienen el mismo nombre de función pero diferentes parámetros (pero la función no se puede sobrecargar con diferentes valores de retorno))
Nota: Puede ser la diferencia en el número de parámetros o el tipo de datos de los parámetros. (El mismo nombre de función realiza la misma función)
El operador "<<" es un operador de desplazamiento a la izquierda en C, pero es un operador de flujo en C ++, que está sobrecargado por el objeto cout.
Ejemplo de sobrecarga de funciones para conversión de temperatura:
---- Tipos de datos complejos
int num[i];
for(i=0;i<10;i++)
{
cout<<"请输入元素第"<<i+1<<"个元素"<<endl;
cin>>num[i];//将输入流向num[i]
}
int total=0;//int total;//如果只定义不进行初始化会产生异常数据。//因为他是个局部变量，La CPU reconoce solo 1 y 0;
Tres tipos de datos: matriz, puntero, estructura.
-----Formación
Una matriz puede almacenar muchos valores del mismo tipo con el mismo nombre de variable. (La matriz aún debe declararse como un tipo específico)
type name[i];(Variables locales, la memoria no es suficiente para ayudarlo a inicializar, las variables locales se almacenan en la pila, los datos en la pila cambian constantemente, no se puede inicializar, dará aleatoriamente un valor grande, por lo que debemos hacerlo al definir variables locales inicialización.)
Definición de macro y variables estáticas: (ambas lo hacen)
#define ITEM 10
const unsigned short ITEM 10;Si cin se ingresa correctamente, el valor de retorno es 0.
while(!0(cin>>nun[i]))
{
cin.clear();//清除输入缓冲区
cin.ignore(100,"\n");
cout<<"输入错误"<<endl;
}La cadena de caracteres definida en lenguaje C: char a [] = "avsgdj";
C ++ también puede usar: std :: string type.
#include<string>//字符串头文件
int main()
{
std::string str;//定义一个字符串变量str,注意把命名空间也得引入进来，他也是在std这个命名空间里面。
std::cout<<"请随便输入一个字符串";
//std::cin>>str;//接收输入，存入到字符串str里面去。//cin遇到空格就以为输入的字符串结束了（acd sdc dfe比如输入三个中间有空格那么cin就只会接收acd后边遇到空格就以为输入的字符串结束了），所以下边使用getline();接收字符串
std::getline(std::cin,str);//用cin的方式存放到str里面去
std::cout<<str<<"\n";//再把字符串输出。
return 0;
}El tipo de std :: string (clase estándar) en C ++ es en realidad un objeto definido en la biblioteca estándar de C ++, con muchas funciones integradas.
Sobre el método interno de cadena:
Extraer subcadena;
Comparar cadenas
Agregar cadena;
Cadena de búsqueda
y muchos más;
---- Puntero ((La dirección es la dirección en la memoria))
La variable ordinaria almacena un valor, que es un valor numérico, mientras que la variable de puntero almacena una dirección. El tipo de puntero debe ser coherente con el tipo de variable cuya dirección guarda.
Los programas existen en forma de archivos en el disco duro, pero su operación ocurre en la memoria de la computadora (sin memoria, el disco duro y la CPU por sí solos no pueden funcionar, y la CPU no puede realizar operaciones directamente desde el disco duro. Como este middleware).
//以下这些语句声明的变量，在内存中的存放情况。
int a=-12;
char b=M;
float c=3.14;Icono de memoria:
Entonces, cómo la variable que declaramos se coloca en la memoria (a es un tipo entero que ocupa 4 bytes y un tipo de carácter ocupa un byte) El nombre de la variable es realmente conocido por el compilador, el compilador directamente Este nombre estará directamente vinculado a la dirección en todo el programa (su nombre no se almacena en la memoria).
Alineación: ¿Por qué el valor de la variable de punto flotante c se almacena desde la dirección de memoria 8 en lugar de la dirección de memoria 5?
(En C ++, los tipos de variables se alinean de acuerdo con sus límites naturales (¿qué es un límite natural? Generalmente está alineado con la CPU, y un byte es igual a 8 bits) (esta alineación se puede ignorar, el compilador lo manejará automáticamente por nosotros Para este tipo de problema, solo necesitamos definir una variable para asignarle un valor))
Direccionamiento: (La memoria es la dirección y los datos almacenados en la dirección. El nombre de la variable es para el compilador. El compilador enganchará la dirección y el nombre de la variable detrás de escena. Después de la traducción, el nombre de la variable se convertirá en la dirección). Para las variables, puede usar dos Formas de indexarlo.
El primero es a través del nombre de la variable, como definir a = -12; si lo mostramos, simplemente revise el nombre de la variable directamente.
El otro es por dirección, que es más real. (De hecho, el nombre de la variable se convertirá en una dirección después de la compilación final y el enlace)
Operador de dirección: &. Función para obtener la dirección de la variable. como
int a = 3; // Definir una variable a cuyo valor es 3;
cout << "La dirección de la variable es:" << & a; // Para generar esta dirección directamente es agregar un ampersand antes del nombre de la variable. (La pequeña Q pregunta: ¿Se toma esta dirección de la columna de la izquierda en la figura anterior?) La salida aquí es una dirección de 64 bits y 8 bytes ocupada por este programa variable después de su ejecución.
Little Q hace una pregunta: defina una variable como Int a = 5; hay dos formas de acceder al valor de la variable, la primera es a través del nombre de la variable. El segundo es por dirección. Dije antes que el nombre de la variable se convertirá en una dirección después de compilar y vincular. ¿Esta dirección es la misma que la dirección donde se almacena el valor de la variable arriba?
La pequeña O responde: Sí, debe ser la misma dirección, porque todos se refieren al mismo fragmento de memoria.
La dirección es una ubicación determinada en la memoria de la computadora y el puntero es una variable de tipo especial que se utiliza para almacenar la dirección.
La forma de declarar un tipo de variable de puntero * pointerName; // El tipo de puntero * El nombre del puntero; // (La dirección se almacena en la variable de puntero)
int *p1,p2,p3;//这个定义的指针变量只有一个p1，而p2和p3都是整型变量。
int *p1,*p2,*p3;//这才是声明三个指针变量。(Se permiten variables de puntero vacías, void * p; // En este caso, el puntero solo almacena una dirección, y no dice a qué tipo apunta el puntero)
456 se almacena en la variable a, y el código ascii de c se almacena en la variable b en lugar de c (los caracteres se almacenan en ASCII en la memoria. Dígale que es un carácter y leerá el valor ASCII del carácter. Salga y luego verifique la tabla ASCII y luego muéstrela).
Lo que se almacena en aPointer es 0 (¿por qué no 0 a 3? Porque solo necesita saber su dirección inicial, y luego usar sizeof () para saber su longitud), porque aPointer almacena la dirección de ay la dirección de una variable Es de 0 a 3, la dirección de la variable b es de 4 a 7 y bPointer es 4.
Si * aPoint = 123; se convertirá en
La pequeña Q pregunta:
El valor de a se puede cambiar mediante el puntero.
Lo anterior * p = 5; // significa que se trata de una desreferencia del puntero y una asignación del puntero.
La pequeña O responde: p apunta a a, y le asigna un valor de 5 a * p, luego asigna un valor de 5 y, por supuesto, el valor de a cambiará. p no almacena el valor real, a solo almacena el valor, yp apunta a a, por lo que los valores de ay * p son siempre los mismos, porque solo hay una memoria para almacenar valores.
La pequeña Q pregunta: Bien, entonces * p = 5 asigna un valor a * p en lugar de hacer que p apunte a a? ¿La dirección de p no ha cambiado? ¿O un?
Respuesta de la pequeña O: Bueno, el punto de p no ha cambiado. Aquí * significa obtener el valor al que apunta el puntero, no indicar el puntero.
La pequeña Q pregunta:
, El significado de esta oración no es enfatizar la dirección, sino enfatizar los datos. Entonces * p = 5; Aquí está el uso de variables de puntero, ¿no significa que p apunta a 5? En cambio, p todavía apunta a a. ¿Es solo que los datos correspondientes a la variable a en este momento son 5, no 3?
La pequeña O respondió: Sí.
Si no está asignado o no existe, entonces la dirección que guardó es imaginaria.
--- Punteros y matrices
La computadora guarda la matriz como un conjunto de bloques de memoria contiguos.
La matriz tiene muchas direcciones, cada dirección tiene un elemento, como la dirección 0, 4, 8, etc .; mientras que un puntero solo puede almacenar una dirección, el nombre de la matriz es en realidad un puntero (apunta a la primera dirección de la matriz, que es la primera dirección). La dirección de un elemento).
int * p1 = & myArray [0];
int * p2 = myArray; // Estas dos oraciones son equivalentes. // Realice el almacenamiento de la dirección base del arreglo con una variable de puntero.
p1 ++ // no simplemente hace +1 en la dirección, sino que la incrementa de acuerdo con el tipo de datos de la matriz al que apunta, es decir, + sizeof (int);
#include<iostream>
using namespace std;
void print(int *pbegin,int *pend)
{
while (pbegin != pend)
{
cout << *pbegin;
cout << '\n';
++pbegin;
}
}
void print(char *pbegin, char *pend)
{
while (pbegin != pend)
{
cout << *pbegin;
cout << '\n';
++pbegin;
}
}
int main()
{
int num[5] = { 0,1,2,3,4 };
char name[5] = { 'f','i','s','h','c' };
print(num, num + 5);
cout << '\n';
print(name, name + 5);
cout << "\n";
return 0;
}Cambie la función sobrecargada anterior para usar una plantilla para simplificar:
template <typename elemType> //模板的名字eleType
void print(elemType *pbegin, elemType *pend)
{
while (pbegin != pend)
{
cout << *pbegin;
cout << '\n';
++pbegin;
}
}----- La base del objeto -> Estructura
La estructura es un tipo de datos compuesto por otros tipos de variables.
Los punteros también pueden apuntar a estructuras, al igual que apuntan a otras variables.
Cómo eliminar la referencia a cada miembro de la estructura apuntado por un puntero (es decir, acceder al valor de cada miembro a través de un puntero).
En el caso de una matriz, el puntero apunta a uno de sus elementos básicos, y luego el tipo de puntero se agrega a la pasada siguiente, y el puntero aumenta directamente en 1 para apuntar al siguiente elemento.
La estructura es similar a la matriz, y el puntero apunta a la posición del primer miembro. Si accede al siguiente, solo necesita agregar el puntero al ancho de los primeros (primeros) miembros (tenga en cuenta que no suma 1 ni resta 1, Porque los tipos de datos en la estructura son diferentes).
//定义一个结构
struct FishOil
{
std::string name;
std::string id;
char sex;
};
//创建一个FishOil的结构变量
FishOil jiayu={"小甲鱼","fishc",'M'};
//创建一个指向该结构的指针
FishOil *pjiayu=&jiayu;//此处的jiayu是一个结构类型的变量//指针的类型必须与指向的地址的变量的类型一致，所以pjiayu指针的类型也是FishOil。
//我们可以通过对指针进行解引用来访问相应的变量值
(*pjiayu).name="白天";//改名字//因为*pjiayu就是相当于这个结构变量 jiayuTambién puede utilizar el segundo método para acceder:
pjiayu->name="白天";//指针的话可以用箭头的
pjiayu->id="0001234";
pjiayu->sex='F';
cout<<pjiayu->name;
cout<<pjiayu->id;
cout<<pjiayu->sex;Tipo de unión
union mima
{
unsigned long birthday;
unsigned short ssn;
char *get;
};//定义联合体
mima mima1;//创建变量Tipo enumerado
enum weekday{M,T,W,T,F};//定义枚举类型
weekdays today;//创建该类型的变量
today=T;//对其进行赋值（赋值只能是赋上边的5个中的一个）typedef type (define el alias del tipo)
//typedef用来替换类型别名
typedef int* intpointer;
intpointer mypointer;//intpointer就相当于int*;Tipo de vector (vector) tipo --- (una combinación de matriz y lista vinculada)