[Estación de memoria C++] Espacio de nombres

Concepto de espacio de nombres

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存 在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化， 以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

Cuando muchas personas entran en contacto con C ++ por primera vez, saben que imprimir una línea hello worldse escribe así:

#incluye
el uso del espacio de nombres std;
int main()
{ cout << “hola mundo” << endl; }

Pero si les pregunto qué son iostream y namespace std, y qué papel desempeñan en esta línea de código, muchos principiantes básicamente no pueden responder, solo saben cómo escribirlo, pero no conocen el significado.

Entonces ahora comience a comprender el concepto de espacio de nombres.
大家都知道C++是在c语言基础上建立的，c语言很多地方存在很多缺陷的，C++就创建了一个命名空间的概念来弥补这一缺陷
这一缺陷是什么呢？创建一个全局变量 int rand = 0 ,你只引入了头文件 <stdio.h> ,利用printf打印出rand,不会产生任何问题。可当你再引用了 <stdlib.h> ，再次运行程序就会出现问题

这里报错，显示rand重定义，这里的问题叫做命名冲突，因为 stdlib.h 这个库里面已经定义了rand,且定义成的一个函数，而我们这个全局变量rand是int类型的元素，系统在识别这个rand的时候就会找到两个rand，它不知道去打印哪一个，当然这里刚好rand在库里面是个函数 且与%d发生冲突，显示两个错误

En lenguaje C, la forma más simple y tosca de resolver este problema es cambiar el nombre de la variable para evitar conflictos de nombres con variables del mismo nombre en la biblioteca. Esto ciertamente puede resolver el problema, pero si necesita trabajar en grupos para completar En un proyecto en equipo, las variables individuales de cada grupo son las mismas. ¿Qué hacer en este momento? No pueden pelear directamente entre sí. Esto reducirá en gran medida la eficiencia del trabajo y afectará la atmósfera del equipo, por lo que este método es obviamente No recomendable.

Dado que el lenguaje C no puede resolver este problema, se ha propuesto C ++ 命名空间para resolverlo .
Aquí se introduce una palabra clave namespace. Su función es crear un dominio para proteger la variable rand creada. La siguiente es la implementación del código.

namespace Yuan
{
    
    
	int rand = 0;
}
int main()
{
    
    
	printf("%d\n", rand);
}

namespaceEl siguiente nombre puede ser el que quieras. Mientras lo recuerdes,
no habrá conflicto de nombres. Lo que se imprime en main es el rand en la función de biblioteca (para ser precisos, accede al dominio global para buscar rand), no Yuan.
Si desea imprimir el rand dentro de Yuan, debe agregarlo delante del randYuan::

namespace Yuan
{
    
    
	int rand = 0;
}
int main()
{
    
    
	printf("%d\n", Yuan::rand);
}

namespaceLo que se crea es un dominio local llamado Yuan, aquí debemos revisar las variables globales y las variables locales en el lenguaje C.

int i = 0;
int main()
{
    
    
	int i = 1;
	printf("%d", i);
}

Ahora te hago una pregunta, ¿la i impresa aquí es 0 o 1?

La respuesta es 1. Uno está satisfecho aquí 就近原则. El resultado impreso es 1. Aquí está la variable local i en el dominio local a la que se accede directamente.

Pero, ¿qué sucede si desea acceder a la variable global i en el dominio local?

Necesito agregar delante de i::

int i = 0;
int main()
{
    
    
	int i = 1;
	printf("%d\n", ::i);
	printf("%d\n", i);
}

::Se llama operador de dominio y su función es especificar en qué dominio se encuentra la i. ::El lado izquierdo aquí está en blanco, lo que significa que se debe encontrar en el dominio global.

Por lo tanto, el problema de los conflictos de nombres se puede resolver fácilmente con el concepto de espacio de nombres. Hay tres grupos ABC. Todas las variables escritas por cada grupo se almacenan en sus propios espacios de nombres definidos, y los espacios de nombres se transfieren respectivamente al nodoA, nodoB, nodoC. Incluso si hay las mismas variables en sus respectivos espacios de nombres, no se recibirán. cualquier impacto

Definición de espacio de nombres

1. Definición normal del espacio de nombres

Se pueden definir variables, funciones, tipos, etc. en el espacio de nombres.

namespace Yuan
{
    
    
	int rand = 0;
	void func()
	{
    
    
		printf("func()\n");
	}

	struct TreeNode
	{
    
    
		struct TreeNode* left;
		struct TreeNode* right;
		int val;
	};
}

int main()
{
    
    
	printf("%p\n", rand);
	printf("%p\n", Yuan::rand);

	Yuan::func();

	struct Yuan::TreeNode node;

	return 0;
}

2. Los espacios de nombres se pueden anidar

Los espacios de nombres se pueden anidar, al igual que las declaraciones de bucle.

namespace sql
{
    
    
	int a = 0;
	namespace Yuan
	{
    
    
		int rand = 0;
		void func()
		{
    
    
			printf("func()\n");
		}

		struct TreeNode
		{
    
    
			struct TreeNode* left;
			struct TreeNode* right;
			int val;
		};
	}
}


int main()
{
    
    
	printf("%p\n", rand);
	printf("%p\n", sql::Yuan::rand);

	sql::Yuan::func();

	struct sql::Yuan::TreeNode node;

	return 0;
}

3. Se permite que existan varios espacios de nombres con el mismo nombre en el mismo proyecto y el compilador eventualmente los sintetizará en el mismo espacio de nombres.

¿Cómo entender esto? Por ejemplo, en un proyecto agregamos Stack.h (pila), Stack.cpp (pila), Queue.h (cola), Queue.cpp (cola), que contienen muchas variables y tipos. , etc. Ahora necesitamos ponerlos en un espacio de nombres. Nos preocuparemos por los conflictos de nombres. ¿Cómo solucionarlo?
Defina un espacio de nombres cada vez que Yuan en estos cuatro archivos y coloque todo en el archivo. Póngalos en espacios de nombres. Estos cuatro Los espacios de nombres tienen el mismo nombre pero no están en el mismo archivo. El compilador los fusionará automáticamente en un espacio de nombres, por lo que no tiene que preocuparse por conflictos de nombres.

namespace Yuan
{
    
    
	typedef int STDataType;
	typedef struct Stack
	{
    
    
		STDataType* a;
		int top;		// 栈顶的位置
		int capacity;	// 容量
	}ST;
}

#include "Stack.h"//栈
#include "Queue.h"//队列

int main()
{
    
    
	Yuan::ST st;
	Yuan::StackInit(&st);

	Yuan::Queue q;
	Yuan::QueueInit(&q);
}

Uso de espacios de nombres

1. Agregue el nombre del espacio de nombres y el calificador de alcance.

int main()
{
    
    
    printf("%d\n", Yuan::a);
    return 0;  
}

Ya hemos introducido el uso de espacios de nombres a través de ámbitos de dominio. Esta también es la forma más básica y sencilla de usar espacios de nombres. Sin embargo, este método se vuelve un poco engorroso cuando los espacios de nombres se usan mucho. Quizás no esté disponible aquí. Agregar operadores de dominio , pero no agregarlos allí generó muchos errores, por lo que hay tres formas:

2. Utilice el uso para presentar un miembro del espacio de nombres.

using Yuan::b;
int main()
{
    
    
    printf("%d\n", Yuan::a);
    printf("%d\n", b);
    return 0;  
}

3. Utilice el uso del espacio de nombres introducción del nombre del espacio de nombres

using namespce N;
int main()
{
    
    
    printf("%d\n", Yuan::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;  
}

4. Utilice el espacio de nombres std C ++ introducción al espacio de nombres de la biblioteca estándar

Los dos primeros son relativamente conservadores. Este es muy audaz y expande directamente toda la biblioteca estándar de C++. Aunque evita ciertos conflictos en gran medida, puede haber riesgo de conflictos si se expanden todos de esta manera, por lo que no es Se recomienda expandirlos todos directamente. Úselo, si desea usarlo, debe escribirlo así.

#include<iostream>
//using namespace std
int main()
{
    
    
	std::cout << "hello world" << std::endl;
	return 0;
}