Directorio de artículos
Uno, puntero
Se puede acceder a la memoria indirectamente a través del puntero, y el número en la memoria se puede leer o escribir
-
El número de memoria se registra a partir de 0, generalmente representado por números hexadecimales.
-
Puede usar variables de puntero para guardar direcciones
gramática:数据类型 * 变量名；
Ejemplo
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//指针定义
int *p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;
system("pause");
return 0;
}
Resultado de salida
Desreferenciar es devolver el objeto correspondiente en la dirección de memoria
En un sistema operativo de 32 bits, un puntero ocupa 4 bytes de espacio, independientemente del tipo de datos
En un sistema operativo de 64 bits, el puntero ocupa un tamaño de espacio de bytes
Puntero nulo: La variable de puntero apunta al espacio numerado 0 en la memoria, que se utiliza para inicializar la variable de puntero.
Nota No se puede acceder a la memoria a la que apunta el puntero nulo (el número de memoria entre 0 y 255 está ocupado por el sistema, por lo que no se puede acceder)
Puntero salvaje: La variable de puntero apunta a un espacio de memoria ilegal
Los punteros nulos y los punteros salvajes no son el espacio que solicitamos, así que no visite
1, puntero modificado const
-
puntero constante de puntero modificado const
-
constante de puntero constante modificada const
-
const modifica tanto punteros como constantes
Puntero constante: El punto del puntero se puede cambiar, pero el valor al que apunta el puntero no se puede cambiar
const int * p = &a;
int a = 10;
int b = 10;
int *p = &a;
*p = 20; //错误，指针指向的值不可以改
p = &b; //正确，指针指向可以改
Constante de puntero: No se puede cambiar el apuntado del puntero, se puede cambiar el valor al que apunta el puntero
int * const p = &a;
int a = 10;
int b = 10;
int *p = &a;
*p = 20; //正确，指针指向的值可以改
p = &b; //错误，指针指向不可以改
const modifica tanto punteros como constantes: El punto del puntero y el valor señalado por el puntero no se pueden cambiar
const int * const p = &a;
2. Punteros y matrices
Utilice punteros para acceder al contenido de la matriz.
Ejemplo
#include <iostream>
using namespace std;
int main()
{
int arr[9] = {
1,2,3,4,5,6,7,8,9 };
int *p = arr;
for(int i = 0; i < 9; i++)
{
cout << "利用指针输出数组中第" << i + 1<< "个数：" ;
cout << *p << endl;
p++;
}
system("pause");
return 0;
}
Resultado de salida
3. Punteros y funciones
Usando punteros como parámetros de función, puede modificar el valor del parámetro real (transferencia de dirección)
Ejemplo
#include <iostream>
using namespace std;
//地址传递，与值传递不同，地址传递可以改变主函数中实参的值
void swap(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int a = 10;
int b = 20;
swap(&a, &b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
Resultado de salida
3. Punteros, matrices, funciones
Encapsular una función y utilizar la clasificación de burbujas para lograr una clasificación ascendente de matrices de números enteros
#include<iostream>
using namespace std;
//冒泡排序函数
void bubble(int *arr, int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[10] = {
4,6,9,5,3,2,7,8,1,10 };
int len = sizeof(arr) / sizeof(arr[0]);
bubble(arr, len);
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
Resultado de salida
En segundo lugar, la estructura
La estructura pertenece al usuariopersonalizarTipos de datos, lo que permite a los usuarios almacenar diferentes tipos de datos.
1. Definición y uso de estructura
gramática:struct 结构体名 { 结构体成员列表 }；
Hay tres formas de crear variables a través de estructuras:
-
estructura nombre de la estructura nombre de la variable
-
nombre de la estructura de la estructura nombre de la variable = {valor del miembro 1, valor del miembro 2 ...}
-
Por cierto, crea variables al definir la estructura.
Ejemplo
#include<iostream>
#include<string>
using namespace std;
struct student
{
string name;
int age;
int score;
}s3; //定义结构体时顺便创建变量
int main()
{
// 1、struct 结构体名 变量名
struct student s1;
s1.name = "张三";
s1.age = 17;
s1.score = 90;
cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
// 2、struct 结构体名 变量名 = { 成员1值，成员2值... }
struct student s2 = {
"李四",17,87 };
cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;
//3、定义结构体时顺便创建变量
s3.name = "王五";
s3.age = 18;
s3.score = 91;
cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
system("pause");
return 0;
}
Resultado de salida
2. Matriz de estructuras
Coloque la estructura personalizada en la matriz para facilitar el mantenimiento
gramática:struct 结构体名 数组名[ 元素个数 ] = { {}，{}，......}
Ejemplo
#include<iostream>
#include<string>
using namespace std;
//1、定义结构体
struct student
{
string name;
int age;
int score;
};
int main()
{
//2、创建结构体数组
struct student stu[2]=
{
{
"张三", 18, 95},
{
"李四", 17, 90}
};
//3、给结构体数组中的元素赋值
stu[1].name = "王五";
//4、遍历结构体数组
for (int i = 0; i < 2; i++)
{
cout << "姓名：" << stu[i].name
<< " 年龄：" << stu[i].age
<< " 分数：" << stu[i].score << endl;
}
system("pause");
return 0;
}
Resultado de salida
3. Puntero de estructura
Accede a los miembros de la estructura a través del puntero.
Utilice el operador -> para acceder a los atributos de la estructura a través de punteros de estructura
== Acceda a las propiedades en la estructura a través del puntero de estructura, debe usar '->' ==
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
int main()
{
//创建结构体变量
struct student s = {
"张三", 18, 95 };
//通过指针指向结构体变量
struct student * p = &s;
//通过指针访问结构体变量
cout << "姓名：" << p->name
<< " 年龄：" << p->age
<< " 分数：" << p->score << endl;
system("pause");
return 0;
}
4. Estructura estructura anidada
Ejemplo
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
struct teacher
{
int id;
string name;
int age;
struct student stu;
};
int main()
{
teacher t;
t.id = 001;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 17;
t.stu.score = 90;
cout << "老师姓名：" << t.name
<< " 老师id：" << t.id
<< " 老师年龄：" << t.age<<endl
<< "学生姓名：" << t.stu.name
<< " 学生年龄：" << t.stu.age
<< " 学生分数：" << t.stu.score << endl;
system("pause");
return 0;
}
5. Estructura como parámetro de función
Pasar la estructura como un parámetro como una función
Método de entrega:
-
Pasar por valor
-
Pase de dirección
Ejemplo
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
//打印学生信息
//1、值传递
void print01(struct student s)
{
s.age = 100;
cout << "print01学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
}
//2、地址传递
void print02(struct student *p)
{
p->age = 200;
cout << "print02学生姓名：" << p->name
<< " 学生年龄：" << p->age
<< " 学生分数：" << p->score << endl;
}
int main()
{
struct student s;
s.name = "张三";
s.age = 18;
s.score = 90;
print01(s);
cout << "main01学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
print02(&s);
cout << "main02学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
system("pause");
return 0;
}
Resultado de salida
6, el uso de const en la estructura.
Utilice const para evitar un mal funcionamiento
Cambie los parámetros formales de la función a punteros, lo que puede reducir el espacio de memoria y ya no es necesario realizar copias.
Ejemplo
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
void print(const student *s)
{
//加入const后，在函数中不可再修改结构体中数据属性
cout << "学生姓名：" << s->name
<< " 学生年龄：" << s->age
<< " 学生分数：" << s->score << endl;
}
int main()
{
struct student s = {
"张三",20,90 };
//通过函数来打印结构体信息
print(&s);
system("pause");
return 0;
}
[Nota] El curso de aprendizaje es-Tutorial de C ++ del Programa Dark Horse