c++ - que - punteros en c

char y char*(puntero)

Question

Me gustaría entender cómo funcionan los punteros, así que creé este pequeño programa. antes que nada, creo un puntero ap, que apunta a un char.

La primera pregunta es en este punto. Si creo un puntero, su valor es una dirección de memoria (si lo apunto a un objeto no puntero), pero esta vez es "jaja" en mi ejemplo. ¿Por qué funciona de esta manera en char *? ¿Y cómo puedo agregarle valor con cin >> p?

Mi segunda pregunta es que creé un aq char, que tiene el valor del puntero * p en el punto en que lo creé. PERO su valor y dirección son "h" también, pero ¿por qué? ¡Debe ser la dirección de memoria de este objeto char! No tiene sentido: D (mingw - gcc)

int main() {
    char *p;
    cin >> p;                      //forexample: haha
    char q = *p;
    cout << "&q = " << &q << endl; //&q = h
    cout << "q = " << q << endl;   //q = h
    return 0;
}

MÁS: si asigna memoria primero con char a [100]; char * p = a; entonces & q = h »ŢĹ, entonces" h "y algo de desorden. ¡pero debería ser una dirección de memoria! y mi pregunta es, ¿por qué no es la dirección entonces?

Answer 1

Deberías tener algo como:

#include <iostream>
using namespace std;

en la parte superior de tu programa O podría omitir el using y referirse a std::cin y std::cout .

int main() {
    char *p;

p es un puntero, pero no lo ha inicializado, por lo que podría apuntar a cualquier parte o a ninguna parte. Necesita inicializarlo, por ejemplo con:

p = new char[100];

...

    cin >> p;                      //forexample: haha

Esto está bien si has inicializado p para apuntar a alguna parte, excepto que puedes desbordar el búfer al que apunta si ingresas demasiados datos. Eso está bien para un programa de prueba simple como este, pero en la práctica querrás tomar medidas para evitarlo.

    char q = *p;
    cout << "&q = " << &q << endl; //&q = h

&q es de tipo char* , un puntero a char . Enviar un valor de char* a cout no imprime el valor del puntero (una dirección de memoria); imprime la cadena a la que apunta. (Aunque obtengo algunos resultados extraños cuando lo ejecuto yo mismo, me puede estar faltando algo.) Si quiere ver el valor del puntero, cúbralo a void* :

count << "&q = " << (void*)&q << endl;

(O podría usar uno de los moldes específicos de C ++; no estoy seguro de cuál es el mejor).

    cout << "q = " << q << endl;   //q = h

Aquí q es solo un char , por lo que esto imprime su valor como un carácter: h .

    return 0;
}

Answer 2

Lo primero que debe aprender y recordar siempre sobre los punteros es asegurarse de asignarles memoria, de lo contrario, su programa no se ejecutará correctamente.

Su código debería modificarse de la siguiente manera para asignar memoria de manera que "cin" pueda escribir la entrada del usuario en la memoria asignada:

int main() {
    char *p = new char[1024];      // allocate memory so cin
    cin >> p;                      //forexample: haha
    char q = *p;
    cout << "&q = " << &q << endl; 
    cout << "q = " << q << endl;   
    return 0;
}

Ahora, un puntero de carácter es una variable que apunta a una posición en la memoria que contiene un conjunto de caracteres (no necesariamente un carácter, tal vez más de uno, tal vez ninguno como en el caso del valor especial nulo), mientras que una variable de carácter está realmente conteniendo un solo personaje (no un conjunto de caracteres).

Los operadores básicos al tratar con punteros es la & (dirección de) y * (valor en). El & recupera la dirección de una variable, así que si tenemos [char q;] entonces [& q] sería un puntero de carácter. Por otro lado, * recupera el valor en el puntero dado, de modo que si tenemos [char * p;] entonces [* p] sería el carácter en la memoria en el que p está apuntando.

Ahora volviendo a su ejemplo, los comentarios en línea para la ilustración

int main() {
    // allocate a place of 1024 character in memory
    // and let p points to that place
    char *p = new char[1024];      

    // call cin to read input from the user and save
    // it in memory at the location pointed to by p
    // NOTE: cin would put an extra NULL character 
    // at the end to terminate the string
    cin >> p;                      //forexample: haha

    // Now p would be pointing to a piece of memory like this
    // [h] [a] [h] [a] [/0]

    // use the value at operator to de-reference the pointer
    // p, the result would be a single character which 
    // will be the first character in memory p is pointing at
    char q = *p;

    // printing the value of (the address of q)
    // Note you have a problem here as cout will
    // be handling the memory starting at the address 
    // of q as a string while it is not, so you
    // will get a string starting with "h" and followed
    // by whatever is there in memory by the time of execution
    cout << "&q = " << &q << endl;

    // printing the value of the character q
    cout << "q = " << q << endl; 
    return 0;
}

Espero que ayude

Answer 3

Piensa en char* p; como de dirección en la memoria. No inicializó este puntero para que no apunte a nada, no puede usarlo.

Para estar seguro siempre:
o inicialice el puntero a cero:

char *p = 0; // nullptr in C++11

o inicializar a algunos automático

void foo() {
  char a[100];
  char *p = a;
}

o memoria global:

char a[100];
void foo() {
  char *p = a;
}

o obtener memoria dinámica:

char* p = new char [100];

Luego puede usar p (si no es NULO) para leer datos y leer de p ...

Por su mala interpretación del operator >> (std::istream&, char* p) . Este operador espera que p apunte a cierta memoria (automática, global, dinámica, sin importar), no asigna memoria por sí misma. Simplemente lee caracteres de la secuencia de entrada hasta espacios en blanco y los copia a la memoria apuntada por p , pero p ya debe apuntar a cierta memoria.

Para tomar la dirección de char q; . Por supuesto, puede tomar la dirección de q : &q , y el tipo es char* p . Pero &q es diferente que p , y esto q=*p solo copia el primer caracter apuntado por p a q , no puede cambiar la dirección de q - su dirección es inmutable. Para cout << &q - operator << (ostream&, char* p) espera que p apunte a cadena terminada en NULL - y &q apunta a la memoria que contiene "H" pero lo que está después de este personaje nadie lo sabe - entonces obtendrá algo de basura en la pantalla. Use cout << q para imprimir un solo caracter.