c - son - tipos de datos y operadores en java

¿Cómo explicar los indicadores C(declaración versus operadores unarios) a un principiante? (23)

Corto en declaraciones

Es bueno saber la diferencia entre la declaración y la inicialización. Declaramos las variables como tipos y las inicializamos con valores. Si hacemos ambas cosas al mismo tiempo, a menudo lo llamamos definición.

1. int a; a = 42; int a; a = 42;

int a; a = 42;

Declaramos una int llamada a . Entonces lo inicializamos dándole un valor 42 .

2. int a = 42;

Declaramos e int nombrado a y le damos el valor 42. Se inicializa con 42 . Una definicion.

3. a = 43;

Cuando usamos las variables, decimos que operamos sobre ellas. a = 43 es una operación de asignación. Asignamos el número 43 a la variable a.

Diciendo

int *bar;

declaramos que la barra es un puntero a un int. Diciendo

int *bar = &foo;

declaramos barra e inicializamos con la dirección de foo .

Después de que hemos inicializado la barra , podemos usar el mismo operador, el asterisco, para acceder y operar en el valor de foo . Sin el operador accedemos y operamos en la dirección a la que apunta el puntero.

Además de eso, dejo que la imagen hable.

Qué

Una ASCIIMACIÓN simplificada sobre lo que está sucediendo. (Y aquí una versión de jugador si quieres pausar, etc.)

Recientemente tuve el placer de explicarle los consejos a un principiante en la programación de C y tropecé con la siguiente dificultad. Puede que no parezca un problema si ya sabes cómo usar punteros, pero trata de ver el siguiente ejemplo con una mente clara:

int foo = 1; int *bar = &foo; printf("%p/n", (void *)&foo); printf("%i/n", *bar);

Para el principiante absoluto, la salida puede ser sorprendente. En la línea 2 él / ella acababa de declarar * bar para ser y foo, pero en la línea 4 resulta que * bar es realmente foo en lugar de & foo!

La confusión, se podría decir, se deriva de la ambigüedad del símbolo *: en la línea 2 se usa para declarar un puntero. En la línea 4, se usa como un operador unario que obtiene el valor al que apunta el puntero. Dos cosas diferentes, ¿verdad?

Sin embargo, esta "explicación" no ayuda a un principiante en absoluto. Introduce un nuevo concepto al señalar una sutil discrepancia. Esta no puede ser la forma correcta de enseñarlo.

Entonces, ¿cómo lo explicaron Kernighan y Ritchie?

El operador unario * es el operador de indirección o desreferenciación; cuando se aplica a un puntero, accede al objeto al que apunta el puntero. [...]
La declaración del puntero ip, int *ip está prevista como una mnemotécnica; dice que la expresión *ip es un int. La sintaxis de la declaración de una variable imita la sintaxis de las expresiones en las que podría aparecer la variable .

int *ip debe leerse como " *ip will return an int "? Pero ¿por qué entonces la asignación después de la declaración no sigue ese patrón? ¿Qué pasa si un principiante quiere inicializar la variable? int *ip = 1 (léase: *ip devolverá un int y el int es 1 ) no funcionará como se esperaba. El modelo conceptual simplemente no parece coherente. ¿Me estoy perdiendo de algo?

Editar: Trató de resumir las respuestas aquí .

"Tal vez escribirlo como int * bar hace que sea más obvio que la estrella es en realidad parte del tipo, no parte del identificador". Así que hago. Y digo que es similar a Type, pero solo para un nombre de puntero.

"Por supuesto esto te lleva a problemas diferentes con cosas poco intuitivas como int * a, b".

Creo que el diablo está en el espacio.

Escribiría (no solo para principiantes, sino también para mí): int * bar = & foo; en lugar de int * bar = & foo;

esto debería hacer evidente cuál es la relación entre la sintaxis y la semántica

Debe señalar a un principiante que * tiene un significado diferente en la declaración y la expresión. Como saben, * en la expresión es un operador unario, y * En la declaración no se trata de un operador y solo un tipo de sintaxis que se combina con el tipo para que el compilador sepa que se trata de un tipo de puntero. es mejor decir un principiante, "* tiene un significado diferente. Para entender el significado de *, debes encontrar dónde * se usa"

El tipo de la expresión *bar es int ; por lo tanto, el tipo de la bar variables (y expresiones) es int * . Como la variable tiene un tipo de puntero, su inicializador también debe tener un tipo de puntero.

Hay una incoherencia entre la inicialización y la asignación de variable de puntero; eso es solo algo que debe aprenderse de la manera más difícil.

Este problema es algo confuso cuando se comienza a aprender C.

Estos son los principios básicos que pueden ayudarlo a comenzar:

Hay solo unos pocos tipos básicos en C:
- char : un valor entero con el tamaño de 1 byte.
- short : un valor entero con el tamaño de 2 bytes.
- long : un valor entero con el tamaño de 4 bytes.
- long long : un valor entero con el tamaño de 8 bytes.
- float : un valor no entero con el tamaño de 4 bytes.
- double : un valor no entero con el tamaño de 8 bytes.
Tenga en cuenta que el tamaño de cada tipo generalmente está definido por el compilador y no por el estándar.
Los tipos enteros de short , long y long long son generalmente seguidos por int .
No es obligatorio, sin embargo, y puede usarlos sin int .
Alternativamente, puede simplemente declarar int , pero eso puede ser interpretado de manera diferente por diferentes compiladores.
Entonces para resumir esto:
- short es lo mismo que short int pero no necesariamente lo mismo que int .
- long es lo mismo que long int pero no necesariamente lo mismo que int .
- long long es lo mismo que long long int pero no necesariamente lo mismo que int .
- En un compilador dado, int es short int o long int o long long int .
Si declara una variable de algún tipo, también puede declarar otra variable que la señale.
Por ejemplo:
int a;

int* b = &a;

Entonces, en esencia, para cada tipo básico, también tenemos un tipo de puntero correspondiente.
Por ejemplo: short y short* .
Hay dos maneras de "ver" la variable b (es lo que probablemente confunde a la mayoría de los principiantes) :
- Puede considerar b como una variable de tipo int* .
- Puede considerar *b como una variable de tipo int .
Por lo tanto, algunas personas declararían int* b , mientras que otras declararían int *b .
Pero el hecho es que estas dos declaraciones son idénticas (los espacios no tienen sentido).
Puede usar ya sea b como un puntero a un valor entero, o *b como el valor entero puntual real.
Puede obtener (leer) el valor apuntado: int c = *b .
Y puede establecer (escribir) el valor en punta: *b = 5 .
Un puntero puede señalar cualquier dirección de memoria, y no solo a la dirección de alguna variable que haya declarado previamente. Sin embargo, debe tener cuidado al usar los punteros para obtener o establecer el valor ubicado en la dirección de la memoria apuntada.
Por ejemplo:
int* a = (int*)0x8000000;

Aquí, tenemos una variable que apunta a la dirección de memoria 0x8000000.
Si esta dirección de memoria no está asignada dentro del espacio de memoria de su programa, entonces cualquier operación de lectura o escritura con *a hará que su programa se cuelgue debido a una violación de acceso a la memoria.
Puede cambiar el valor de a con seguridad, pero debe tener mucho cuidado al cambiar el valor de *a .
Type void* es excepcional en el hecho de que no tiene un "tipo de valor" correspondiente que se puede usar (es decir, no se puede declarar void a ). Este tipo se usa solo como un puntero general a una dirección de memoria, sin especificar el tipo de datos que reside en esa dirección.

Hay una razón por la cual el estilo K & R favorece int *p y el estilo Stroustrup favorece int* p ; ambos son válidos (y significan lo mismo) en cada idioma, pero como lo expresó Stroustrup:

La elección entre "int * p" e "int * p" no se trata de lo correcto y lo incorrecto, sino del estilo y el énfasis. C enfatizó expresiones; las declaraciones a menudo se consideraban poco más que un mal necesario. C ++, por otro lado, tiene un fuerte énfasis en los tipos.

Ahora, ya que estás tratando de enseñar C aquí, eso sugiere que deberías enfatizar las expresiones más de ese tipo, pero algunas personas pueden entender más fácilmente un énfasis más rápido que el otro, y eso es sobre ellos en lugar del lenguaje.

Por lo tanto, a algunas personas les resultará más fácil comenzar con la idea de que una int* es una cosa diferente de una int e ir desde allí.

Si alguien hace rápidamente la forma de verlo que usa int* bar para tener bar como algo que no es un int, sino un puntero a int , entonces verán rápidamente que *bar está haciendo algo para bar , y el resto seguirá. Una vez que lo haya hecho, puede explicar luego por qué los codificadores de C tienden a preferir int *bar .

O no. Si hubiera una forma en que todos entendieron el concepto por primera vez, no habrían tenido ningún problema en primer lugar, y la mejor manera de explicárselo a una persona no será necesariamente la mejor manera de explicárselo a otra persona.

La fuente de confusión surge del hecho de que * símbolo puede tener diferentes significados en C, dependiendo del hecho en el que se use. Para explicar el puntero a un principiante, se debe explicar el significado del símbolo * en un contexto diferente.

En la declaración

int *bar = &foo;

el símbolo * no es el operador de indirección . En cambio, ayuda a especificar el tipo de bar informa al compilador que la bar es un puntero a un int . Por otro lado, cuando aparece en una declaración, el símbolo * (cuando se usa como un operador unario ) realiza la indirección. Por lo tanto, la declaración

*bar = &foo;

sería incorrecto ya que asigna la dirección de foo al objeto al que apunta la bar , no a la bar misma.

La razón por la cual la taquigrafía:

int *bar = &foo;

en su ejemplo puede ser confuso es que es fácil leerlo mal como equivalente a:

int *bar; *bar = &foo; // error: use of uninitialized pointer bar!

cuando realmente significa:

int *bar; bar = &foo;

Escrito así, con la declaración de variables y la asignación separadas, no existe tal posibilidad de confusión, y el uso del paralelismo de declaración descrito en su presupuesto de K & R funciona perfectamente:

La primera línea declara una bar variable, de modo que *bar es un int .
La segunda línea asigna la dirección de foo a la bar , haciendo *bar (un int ) un alias para foo (también un int ).

Al introducir la sintaxis del puntero C a los principiantes, puede ser útil adherirse inicialmente a este estilo de separar las declaraciones de puntero de las asignaciones, y solo introducir la sintaxis abreviada combinada (con las advertencias apropiadas sobre su potencial de confusión) una vez que los conceptos básicos de puntero se usan en C ha sido internalizado adecuadamente.

La segunda declaración int *bar = &foo; se puede ver pictóricamente en la memoria como,

bar foo +-----+ +-----+ |0x100| ---> | 1 | +-----+ +-----+ 0x200 0x100

Ahora la bar es un puntero de tipo int contiene la dirección & de foo . Usando el operador unario * deferencia para recuperar el valor contenido apuntado por la bar puntero.

EDITAR : Mi enfoque para hacer entender los indicadores a los principiantes comenzaría a explicar memory address de memory address de una variable, es decir,

Memory Address: cada variable tiene una dirección asociada a la proporcionada por el sistema operativo. In int a; , &a es la dirección de la variable a .

Continuando explicando sobre algunos tipos básicos de variables en C como,

Types of variables: variables pueden contener valores de tipos respectivos pero no direcciones.

int a = 10; float b = 10.8; char ch = ''c''; `a, b, c` are variables.

Introducing pointers: como se dijo anteriormente, por ejemplo, por ejemplo

int a = 10; // a contains value 10 int b; b = &a; // ERROR

Es posible asignar b = a pero no b = &a , ya que la variable b puede contener el valor pero no la dirección, por lo tanto, requerimos Punteros .

Pointer or Pointer variables : si una variable contiene dirección, se conoce como variable de puntero. Use * en la declaración para informar que es un puntero.

• Pointer can hold address but not value • Pointer contains the address of an existing variable. • Pointer points to an existing variable

Mirando las respuestas y comentarios aquí, parece haber un acuerdo general de que la sintaxis en cuestión puede ser confusa para un principiante. La mayoría de ellos proponen algo en esta línea:

Antes de mostrar cualquier código, use diagramas, bocetos o animaciones para ilustrar cómo funcionan los punteros.
Al presentar la sintaxis, explica los dos roles diferentes del símbolo de asterisco . Muchos tutoriales faltan o evaden esa parte. La confusión se produce ("Cuando rompes una declaración de puntero inicializada en una declaración y una tarea posterior, debes recordar eliminar las preguntas frecuentes *" - comp.lang.c ) . Esperaba encontrar un enfoque alternativo, pero supongo que esto es el camino a seguir.

Puede escribir int* bar lugar de int *bar para resaltar la diferencia. Esto significa que no seguirá el enfoque de K & R "la declaración imita el uso", sino el enfoque de Stroustrup C ++ :

No declaramos que *bar sea un número entero. Declaramos que bar es un int* . Si queremos inicializar una variable recién creada en la misma línea, está claro que estamos tratando con bar , no *bar . int* bar = &foo;

Los inconvenientes:

Debe advertir a su alumno sobre el problema de la declaración de múltiples punteros ( int* foo, bar vs int *foo, *bar ).
Tienes que prepararlos para un mundo de dolor . Muchos programadores quieren ver el asterisco junto al nombre de la variable, y tomarán grandes medidas para justificar su estilo. Y muchas guías de estilo imponen esta notación explícitamente (estilo de codificación del kernel de Linux, Guía de estilo de NASA C, etc.).

Editar: Un enfoque diferente que se ha sugerido, es ir al modo "imitar" de K & R, pero sin la sintaxis de "taquigrafía" (ver here ). Tan pronto como omita hacer una declaración y una tarea en la misma línea , todo se verá mucho más coherente.

Sin embargo, tarde o temprano el estudiante tendrá que lidiar con punteros como argumentos de función. Y punteros como tipos de devolución. Y apunta a las funciones. Deberá explicar la diferencia entre int *func(); e int (*func)(); . Creo que tarde o temprano las cosas se derrumbarán. Y tal vez antes es mejor que tarde.

Para que su alumno comprenda el significado del símbolo * en diferentes contextos, primero debe comprender que los contextos son realmente diferentes. Una vez que entienden que los contextos son diferentes (es decir, la diferencia entre el lado izquierdo de una tarea y una expresión general) no es demasiado un salto cognitivo para entender cuáles son las diferencias.

Primero explique que la declaración de una variable no puede contener operadores (demuéstrelo mostrando que poner un símbolo - o + en una declaración de variable simplemente causa un error). Luego continúe mostrando que una expresión (es decir, en el lado derecho de una tarea) puede contener operadores. Asegúrese de que el alumno comprenda que una expresión y una declaración de variable son dos contextos completamente diferentes.

Cuando entienden que los contextos son diferentes, puede continuar explicando que cuando el símbolo * está en una declaración de variable frente al identificador de la variable, significa ''declarar esta variable como un puntero''. Luego puede explicar que cuando se usa en una expresión (como operador unario), el símbolo * es el "operador de desreferencia" y significa "el valor en la dirección de" en lugar de su significado anterior.

Para convencer realmente a su alumno, explique que los creadores de C podrían haber utilizado cualquier símbolo para referirse al operador de desreferencia (es decir, podrían haber usado @ ) pero por alguna razón tomaron la decisión de diseño de usar * .

En general, no hay forma de explicar que los contextos son diferentes. Si el alumno no comprende que los contextos son diferentes, no puede entender por qué el símbolo * puede significar cosas diferentes.

Prefiero leerlo ya que el primero * aplica a int más que a la bar .

int foo = 1; // foo is an integer (int) with the value 1 int* bar = &foo; // bar is a pointer on an integer (int*). it points on foo. // bar value is foo address // *bar value is foo value = 1 printf("%p/n", &foo); // print the address of foo printf("%p/n", bar); // print the address of foo printf("%i/n", foo); // print foo value printf("%i/n", *bar); // print foo value

Quizás recorrerlo un poco más lo hace más fácil:

#include <stdio.h> int main() { int foo = 1; int *bar = &foo; printf("%i/n", foo); printf("%p/n", &foo); printf("%p/n", (void *)&foo); printf("%p/n", &bar); printf("%p/n", bar); printf("%i/n", *bar); return 0; }

Pídales que le digan lo que esperan que sea la salida en cada línea, luego pídales que ejecuten el programa y vean qué sucede. Explique sus preguntas (la versión desnuda allí sin duda provocará algunas, pero puede preocuparse por el estilo, rigor y portabilidad más adelante). Luego, antes de que sus mentes se vuelvan pesimistas por pensar demasiado o se conviertan en zombies después del almuerzo, escriba una función que tome un valor, y la misma que tome un puntero.

En mi experiencia, superar eso "¿por qué se imprime así?" joroba, y luego mostrando de inmediato por qué esto es útil en los parámetros de función mediante el uso práctico (como preludio de algunos materiales básicos de K & R como el análisis de cadenas / procesamiento de matriz) que hace que la lección no solo tenga sentido sino que permanezca.

El siguiente paso es hacer que te expliquen cómo i[0] con &i . Si pueden hacer eso, no lo olvidarán y podrás comenzar a hablar sobre las estructuras, incluso un poco antes de tiempo, para que se haga visible.

Las recomendaciones anteriores sobre cajas y flechas también son buenas, pero también pueden terminar divagando en una discusión completa sobre cómo funciona la memoria, que es una conversación que debe suceder en algún momento, pero que puede distraer del punto inmediato al alcance de la mano. : cómo interpretar la notación de puntero en C.

Si el problema es la sintaxis, puede ser útil mostrar el código equivalente con la plantilla / usar.

template<typename T> using ptr = T*;

Esto puede ser usado como

ptr<int> bar = &foo;

Después de eso, compare la sintaxis normal / C con este solo enfoque de C ++. Esto también es útil para explicar los indicadores de const.

Vi esta pregunta hace unos días, y luego estaba leyendo la explicación de la declaración de tipo de Go en el Blog Go . Comienza con una cuenta de declaraciones de tipo C, que parece ser un recurso útil para agregar a este hilo, aunque creo que ya se han dado más respuestas completas.

C tomó un enfoque inusual e inteligente a la sintaxis de declaración. En lugar de describir los tipos con sintaxis especial, uno escribe una expresión que involucra el elemento que se está declarando, y establece qué tipo tendrá esa expresión. Así
int x;
declara que x es un int: la expresión ''x'' tendrá tipo int. En general, para descubrir cómo escribir el tipo de una nueva variable, escriba una expresión que involucre esa variable que evalúa a un tipo básico, luego coloque el tipo básico a la izquierda y la expresión a la derecha.
Por lo tanto, las declaraciones
int *p; int a[3];
declara que p es un puntero a int porque ''* p'' tiene tipo int, y que a es una matriz de ints porque a [3] (ignorando el valor de índice particular, que se evalúa como el tamaño de la matriz) tiene En t.

(It goes on to describe how to extend this understanding to function pointers etc)

This is a way that I''ve not thought about it before, but it seems like a pretty straightforward way of accounting for the overloading of the syntax.

Ya se señaló que * tiene múltiples roles.

Hay otra idea simple que puede ayudar a un principiante a captar cosas:

Piensa que "=" también tiene múltiples roles.

Cuando la asignación se usa en la misma línea que la declaración, considérela una llamada de constructor, no una asignación arbitraria.

Cuando veas:

int *bar = &foo;

Piensa que es casi equivalente a:

int *bar(&foo);

Los paréntesis tienen precedencia sobre el asterisco, por lo que "& foo" se atribuye mucho más intuitivamente a "barra" en lugar de "barra".

tl; dr:

P: ¿Cómo explicar los indicadores C (declaración versus operadores unarios) a un principiante?

A: no. Explicar punteros al principiante y mostrarles cómo representar sus conceptos de puntero en la sintaxis C después.

Recientemente tuve el placer de explicarle los consejos a un principiante en la programación de C y tropecé con la siguiente dificultad.

La sintaxis de IMO C no es horrible, pero tampoco es maravillosa: no es un gran obstáculo si ya entiendes los indicadores, ni ayuda para aprenderlos.

Por lo tanto, comience por explicar los indicadores y asegúrese de que realmente los entiendan:

Explícales con diagramas de caja y flecha. Puede hacerlo sin direcciones hexadecimales, si no son relevantes, simplemente muestre las flechas que apuntan a otro cuadro o a algún símbolo nulo.
Explique con pseudocódigo: solo escriba la dirección de foo y el valor almacenado en la barra .
Luego, cuando su novato comprenda qué son los indicadores, y por qué, y cómo usarlos; luego muestre el mapeo en la sintaxis C.

Sospecho que el motivo por el cual el texto de K & R no proporciona un modelo conceptual es que ya entendieron los indicadores , y probablemente asumieron que todos los demás programadores competentes en ese momento también lo hicieron. El mnemónico es solo un recordatorio del mapeo del concepto bien entendido, a la sintaxis.

A pointer is just a variable used to store addresses.

Memory in a computer is made up of bytes (A byte consists of 8 bits) arranged in a sequential manner. Each byte has a number associated with it just like index or subscript in an array, which is called the address of the byte. The address of byte starts from 0 to one less than size of memory. For example, say in a 64MB of RAM, there are 64 * 2^20 = 67108864 bytes . Therefore the address of these bytes will start from 0 to 67108863 .

Let''s see what happens when you declare a variable.

int marks;

As we know an int occupies 4 bytes of data (assuming we are using a 32-bit compiler) , so compiler reserves 4 consecutive bytes from memory to store an integer value. The address of the first byte of the 4 allocated bytes is known as the address of the variable marks . Let''s say that address of 4 consecutive bytes are 5004 , 5005 , 5006 and 5007 then the address of the variable marks will be 5004 .

Declaring pointer variables

As already said a pointer is a variable that stores a memory address. Just like any other variables you need to first declare a pointer variable before you can use it. Here is how you can declare a pointer variable.

Syntax: data_type *pointer_name;

data_type is the type of the pointer (also known as the base type of the pointer). pointer_name is the name of the variable, which can be any valid C identifier.

Let''s take some examples:

int *ip; float *fp;

int *ip means that ip is a pointer variable capable of pointing to variables of type int . In other words, a pointer variable ip can store the address of variables of type int only . Similarly, the pointer variable fp can only store the address of a variable of type float . The type of variable (also known as base type) ip is a pointer to int and type of fp is a pointer to float . A pointer variable of type pointer to int can be symbolically represented as ( int * ) . Similarly, a pointer variable of type pointer to float can be represented as ( float * )

Después de declarar una variable de puntero, el siguiente paso es asignarle una dirección de memoria válida. Nunca debe usar una variable de puntero sin asignarle una dirección de memoria válida, porque justo después de la declaración contiene un valor de basura y puede estar apuntando a cualquier parte de la memoria. El uso de un puntero sin asignar puede dar un resultado impredecible. Incluso puede causar que el programa se cuelgue.

int *ip, i = 10; float *fp, f = 12.2; ip = &i; fp = &f;

Fuente: thecguru es de lejos la explicación más simple pero detallada que he encontrado.

Basically Pointer is not a array indication. Beginner easily thinks that pointer looks like array. most of string examples using the

"char *pstr" it''s similar looks like

"char str[80]"

But, Important things , Pointer is treated as just integer in the lower level of compiler.

Let''s look examples::

#include <stdio.h> #include <stdlib.h> int main(int argc, char **argv, char **env) { char str[] = "This is Pointer examples!"; // if we assume str[] is located in 0x80001000 address char *pstr0 = str; // or this will be using with // or char *pstr1 = &str[0]; unsigned int straddr = (unsigned int)pstr0; printf("Pointer examples: pstr0 = %08x/n", pstr0); printf("Pointer examples: &str[0] = %08x/n", &str[0]); printf("Pointer examples: str = %08x/n", str); printf("Pointer examples: straddr = %08x/n", straddr); printf("Pointer examples: str[0] = %c/n", str[0]); return 0; }

Results will like this 0x2a6b7ed0 is address of str[]

~/work/test_c_code$ ./testptr Pointer examples: pstr0 = 2a6b7ed0 Pointer examples: &str[0] = 2a6b7ed0 Pointer examples: str = 2a6b7ed0 Pointer examples: straddr = 2a6b7ed0 Pointer examples: str[0] = T

So, Basically, Keep in mind Pointer is some kind of Integer. presenting the Address.

Here you have to use, understand and explain the compiler logic, not the human logic (I know, you are a human, but here you must mimic the computer ...).

When you write

int *bar = &foo;

the compiler groups that as

{ int * } bar = &foo;

That is : here is a new variable, its name is bar , its type is pointer to int, and its initial value is &foo .

And you must add : the = above denotes an initialization not an affectation, whereas in following expressions *bar = 2; it is an affectation

Edit per comment:

Beware : in case of multiple declaration the * is only related to the following variable :

int *bar = &foo, b = 2;

bar is a pointer to int initialized by the address of foo, b is an int initialized to 2, and in

int *bar=&foo, **p = &bar;

bar in still pointer to int, and p is a pointer to a pointer to an int initialized to the address or bar.

I would explain that ints are objects, as are floats etc. A pointer is a type of object whose value represents an address in memory ( hence why a pointer defaults to NULL ).

When you first declare a pointer you use the type-pointer-name syntax. It''s read as an "integer-pointer called name that can point to the address of any integer object". We only use this syntax during decleration, similar to how we declare an int as ''int num1'' but we only use ''num1'' when we want to use that variable, not ''int num1''.

int x = 5; // an integer object with a value of 5

int * ptr; // an integer with a value of NULL by default

To make a pointer point to an address of an object we use the ''&'' symbol which can be read as "the address of".

ptr = &x; // now value is the address of ''x''

As the pointer is only the address of the object, to get the actual value held at that address we must use the ''*'' symbol which when used before a pointer means "the value at the address pointed to by".

std::cout << *ptr; // print out the value at the address

You can explain briefly that '' '' is an ''operator'' that returns different results with different types of objects. When used with a pointer, the '' '' operator doesn''t mean "multiplied by" anymore.

It helps to draw a diagram showing how a variable has a name and a value and a pointer has an address (the name) and a value and show that the value of the pointer will be the address of the int.

int *bar = &foo;

Question 1 : ¿Qué es el bar ?

Ans : Es una variable de puntero (para escribir int ). Un puntero debe apuntar a una ubicación de memoria válida y luego debe eliminarse la referencia (* bar) usando un operador unario * para leer el valor almacenado en esa ubicación.

Question 2 : ¿Qué es &foo ?

Ans : foo es una variable de tipo int Que está almacenada en alguna ubicación de memoria válida y esa ubicación la obtenemos del operador, & ahora lo que tenemos es una ubicación de memoria válida &foo .

Así que ambos juntos, es decir, lo que el puntero necesitaba era una ubicación de memoria válida y eso es conseguido por &foo para que la inicialización sea buena.

Ahora la bar puntero apunta a la ubicación válida de la memoria y el valor almacenado en ella puede obtenerse desreferenciando, es decir, *bar