En C ++ no puedo captar punteros y clases

Estoy recién salido de la universidad y he trabajado en C ++ desde hace un tiempo. Entiendo todos los conceptos básicos de C ++ y los uso, pero estoy teniendo dificultades para captar temas más avanzados, como punteros y clases. He leído algunos libros y tutoriales y entiendo los ejemplos en ellos, pero cuando veo algunos ejemplos avanzados de la vida real no los puedo descifrar. Esto me está matando porque siento que me está impidiendo llevar mi programación en C ++ al siguiente nivel. ¿Alguien más tiene este problema? Si es así, ¿cómo lo lograste? ¿Alguien sabe de algún libro o tutorial que realmente describa bien los consejos y los conceptos de clase? o tal vez algún código de ejemplo con buenos comentarios descriptivos usando punteros avanzados y técnicas de clase? cualquier ayuda sería muy apreciada.

0
agregado editado
Puntos de vista: 8
FYI, punteros y clases SON los conceptos básicos de C ++.
agregado el autor Wedge, fuente
PD C ++ es un lenguaje muy rico y amplio. Si no puedes entender los ejemplos avanzados, eso no significa necesariamente que te falta algo (el agujero "avanzado" para el conejo de C ++ es muy, muy profundo). Sin embargo, sería útil que proporcionaras más información específica.
agregado el autor Wedge, fuente
Déjame adivinar: estás escribiendo un código matemático computacional y tu falta de comprensión de los indicadores interfiere con el procesamiento de datos multidimensionales. ¿Cerca?
agregado el autor Arkadiy, fuente
Muchas de las respuestas fueron realmente buenas. Muchas gracias a todos los que respondieron. Seguiré algunas respuestas, pero parece que solo debo seguir y obtener más experiencia.
agregado el autor timmyg, fuente
Intenté dejar en claro en mi pregunta, pero tal vez no, que entiendo los consejos y las clases en términos de lecciones y ejemplos de libros de texto. Pero cuando necesito leer y entender el código de otra persona, por ejemplo, una API de software, con punteros y clases es donde me cuesta entender.
agregado el autor timmyg, fuente
¿Cómo trabajas con C ++ por un tiempo sin este conocimiento ...? C ++ sin clases suena como C, y C sin punteros suena como um .....
agregado el autor Aardvark, fuente
No conoces ni una pizca de C ++ si no entiendes el concepto de clases. Y si no entiende los punteros, entonces probablemente tampoco conozca C ... Fallo del sistema educativo
agregado el autor FlySwat, fuente
Por curiosidad, ¿qué idiomas aprendiste en la universidad? Además de los lenguajes funcionales puros, no puedo pensar en ningún idioma que no tenga punteros ni clases.
agregado el autor David Locke, fuente

27 Respuestas

Para comprender mejor los punteros, creo que puede ser útil observar cómo funciona el lenguaje ensamblador con punteros. El concepto de punteros es realmente una de las partes fundamentales del lenguaje ensamblador y la arquitectura de instrucción del procesador x86. Tal vez te deje caer como punteros son una parte natural de un programa.

En cuanto a las clases, aparte del paradigma OO, creo que puede ser interesante observar las clases desde una perspectiva binaria de bajo nivel. No son tan complejos a este respecto en el nivel básico.

You may read Inside the C++ Object Model if you want to get a better understanding of what is underneath C++ object model.

0
agregado

Puede encontrar instructivo este artículo de Joel . Por otro lado, si has estado "trabajando en C ++ durante algún tiempo" y te has graduado en CS, es posible que hayas ido a una JavaSchool (yo diría que no has trabajado en C ++ en absoluto; estado trabajando en C pero usando el compilador de C ++).

Además, solo para secundar las respuestas de hojou y nsanders, los punteros son fundamentales para C ++. Si no entiende los punteros, entonces no comprende los conceptos básicos de C ++ (admitir que este hecho es el comienzo de la comprensión de C ++, por cierto). De manera similar, si no comprende las clases, entonces no comprende los conceptos básicos de C ++ (u OO para el caso).

Para los punteros, creo que dibujar con cajas es una buena idea, pero trabajar en ensamblaje también es una buena idea. Cualquier instrucción que use el direccionamiento relativo le ayudará a comprender qué punteros son bastante rápidos, creo.

En cuanto a las clases (y la programación orientada a objetos de manera más general), recomendaría Stroustrups "The C ++ Programming Language" última edición. No solo es el material de referencia canónico de C ++, sino que también tiene bastante material en muchas otras cosas, desde jerarquías básicas de clases orientadas a objetos y herencia hasta principios de diseño en sistemas grandes. Es una lectura muy buena (si no es un poco gruesa y concisa en algunos puntos).

0
agregado
jajaja, acabo de leer ese artículo de Joel y eso es lo que me hizo venir aquí y buscar preguntas sobre punteros.
agregado el autor Spidey, fuente

Aprende el lenguaje ensamblador y luego aprende C. Entonces sabrás cuáles son los principios subyacentes de la máquina (y, por lo tanto, los punteros).

Los punteros y las clases son aspectos fundamentales de C ++. Si no los entiendes, significa que realmente no entiendes C ++.

Personalmente me reprimí en C ++ durante varios años hasta que sentí que tenía una comprensión firme de C y lo que estaba sucediendo bajo el capó en lenguaje ensamblador. Aunque esto fue hace bastante tiempo, ahora creo que realmente benefició mi carrera entender cómo funciona la computadora a un nivel bajo.

Aprender a programar puede tomar muchos años, pero debes seguir con esto porque es una carrera muy gratificante.

0
agregado

Desde la respuesta de lassevek a una pregunta similar sobre SO :

Punteros es un concepto que para muchos   puede ser confuso al principio, en   particular cuando se trata de copiar   los valores del puntero alrededor y aún   haciendo referencia al mismo bloque de memoria.

     

He descubierto que la mejor analogía es   considerar el puntero como una pieza de   papel con una dirección de la casa en él, y   el bloque de memoria que hace referencia como el   casa real Todo tipo de operaciones   por lo tanto, se puede explicar fácilmente:

     
      
  • Copie el valor del puntero, solo escriba la dirección en una nueva hoja de papel
  •   
  • Listas vinculadas, papel en la casa con la dirección del próximo   casa en ella
  •   
  • Liberar la memoria, demoler la casa y borrar la dirección
  •   
  • Pérdida de memoria, pierde la hoja de papel y no puede encontrar la casa
  •   
  • Liberando la memoria pero manteniendo una referencia (ahora inválida), demuela la   casa, borre una de las piezas de   papel pero tenga otra hoja de papel   con la dirección anterior, cuando   ve a la dirección, no encontrarás un   casa, pero es posible que encuentre algo   que se asemeja a las ruinas de uno
  •   
  • Desbordamiento de búfer, mueve más cosas a la casa de lo que puede   posiblemente en forma, derramando en el   casa de vecinos
  •   
0
agregado

Los punteros y las clases son temas completamente diferentes, así que no los agruparía juntos así. De los dos, diría que los indicadores son más fundamentales.

Un buen ejercicio para aprender sobre qué son los indicadores es el siguiente:

  1. crear una lista vinculada
  2. iterar a través de él de principio a fin
  3. inviértalo de modo que la cabeza ahora sea la parte posterior y la parte posterior ahora la cabeza

Hazlo todo en una pizarra primero. Si puede hacer esto fácilmente, no debería tener más problemas para comprender qué son los indicadores.

0
agregado

Estábamos discutiendo algunos de los aspectos de C ++ y OO en el almuerzo, alguien (un gran ingeniero en realidad) estaba diciendo que, a menos que tenga una sólida experiencia en programación antes de aprender C ++, literalmente lo arruinará.

Recomiendo aprender otro idioma primero, luego cambiar a C ++ cuando lo necesite. No es que los punteros tengan algo grandioso, simplemente son una pieza residual de cuando era difícil para un compilador convertir las operaciones en un ensamblaje eficiente sin ellas.

Actualmente, si un compilador no puede optimizar una operación de matriz mejor que utilizando punteros, su compilador está roto.

Por favor, no me malinterpreten, no digo que C ++ sea horrible ni nada por el estilo y no quiero iniciar una discusión de defensa, lo he usado y lo uso de vez en cuando, solo te recomiendo que comiences con otra cosa. .

Realmente no es como aprender a manejar un auto manual y luego poder aplicarlo fácilmente a una automática, es más como aprender a conducir en una de esas enormes grúas de construcción y luego asumir que se aplicará cuando comiences a conducir un auto. se encuentra manejando su auto en el medio de la calle a 5 mph con las luces de emergencia encendidas.

[edit] repasando ese último párrafo - ¡Creo que esa puede haber sido la analogía más precisa que he tenido!

0
agregado
¿Algún idioma que sugieres aprender primero? sería Python una buena opción? Actualmente estoy tratando de aprender PHP y c ++, sintaxis sabia que son bastante similares.
agregado el autor timmyg, fuente
Ah, y si REALMENTE desea aprender conceptos de programación de vanguardia, mire a Scala. Honestamente, puede ser el mejor debido a todos los conceptos que te expone de inmediato. Hascal y Lisp también son conocidos por enseñar buenos conceptos de programación.
agregado el autor Bill K, fuente
C # y Java son buenos porque se comprueban en tiempo de compilación y, sinceramente, es un buen hábito para entrar. Si quieres tontear, Python es bueno. Si está haciendo un sitio web, ruby on Rails: punto.
agregado el autor Bill K, fuente

Solía ​​tener un problema para entender los punteros en pascal. :) Una vez que comencé a hacer punteros de ensamblador era realmente la única forma de acceder a la memoria y simplemente me golpeaba. Puede sonar como un plano lejano, pero probar el ensamblador (que siempre es una buena idea para tratar de entender de qué se trata realmente la computadora) probablemente le enseñará consejos. Las clases, bueno, no entiendo tu problema, ¿fue tu educación una programación puramente estructurada? Una clase es solo una forma lógica de ver modelos de la vida real: estás tratando de resolver un problema que podría resumirse en una cantidad de objetos/clases.

0
agregado

Para los punteros:

Descubrí que esta publicación tuvo una discusión muy atenta sobre los indicadores. Quizás eso ayude. ¿Estás familiarizado con refrences como en C #? ¿Eso es algo que realmente refiere a algo más? Eso es probablemente un buen comienzo para entender los indicadores.

Además, consulte la publicación de Kent Fredric a continuación en otra forma de presentarse a los punteros.

0
agregado

Para clases:

El momento decisivo para mí fue cuando aprendí sobre interfaces. La idea de abstraer los detalles de cómo escribiste resolvió un problema, y ​​dar solo una lista de métodos que interactúan con la clase fue muy perspicaz.

De hecho, mi profesor explícitamente nos dijo que calificaría nuestros programas conectando nuestras clases a su arnés de prueba. La calificación se haría en función de los requisitos que nos brindó y si el programa se bloqueó.

Para resumir, las clases te permiten cerrar la funcionalidad y llamarla de una manera más limpia (la mayoría de las veces, siempre hay excepciones)

0
agregado
Un arnés de prueba es un código que ejerce otro conjunto de código. Mi profesor básicamente tenía un programa principal que llamaba funciones en nuestra clase. Realizaría la prueba, marcaría una nota, eliminaría su archivo e insertaría el siguiente archivo de estudiantes en su solución y repetiría todo el proceso.
agregado el autor Jason Z, fuente
¿Qué es un "arnés de prueba"?
agregado el autor DarenW, fuente

Supongamos que un puntero es una dirección de matriz.

x = 500;//memory address for hello;
MEMORY[x] = "hello"; 
print  MEMORY[x]; 

es una simplificación gráfica, pero en la mayoría de los casos, siempre y cuando no quieras saber qué número es ese o lo pongas a mano, estarás bien.

Cuando entendí C, tenía algunas macros que tenía, que más o menos me permitían usar punteros al igual que eran un índice de matriz en la memoria. Pero hace tiempo que perdí ese código y hace tiempo que lo olvidé.

Recuerdo que comenzó con

#define MEMORY 0; 
#define MEMORYADDRESS( a ) *a;

y eso por sí solo no es útil. Con suerte, alguien más puede ampliar esa lógica.

0
agregado
Sí, no lo entiendo, creo que esta es una gran manera de entender los indicadores. Las matrices son más fáciles de entender que los punteros, IMO, así que creo que es un gran punto de partida.
agregado el autor Doug T., fuente
Creo que este es un excersize muy útil. Diablos en muchos sistemas integrados No tenía un puntero a las cosas asignadas para mí, tenía un índice de matriz :).
agregado el autor Doug T., fuente
para aquellos de ustedes que me critican por esta publicación, funciona. Lo usé, ayudé a otros con eso. El hecho de que el sistema operativo lo resuma por completo no es importante para el ejercicio.
agregado el autor Kent Fredric, fuente

To understand pointers, I can't recommend the K&R book highly enough.

0
agregado

¿Leíste el lenguaje de programación C ++ de Bjarne Stroustrup? Él creó C ++.

El C ++ FAQ Lite también es bueno.

0
agregado

El punto en el que realmente obtuve los punteros fue la codificación de TurboPascal en un FatMac (alrededor de 1984 más o menos), que era el lenguaje Mac nativo en ese momento.

La Mac tenía un modelo de memoria extraño por el cual cuando se asignaba la dirección la memoria se almacenaba en un puntero en el montón, pero la ubicación de eso no estaba garantizada y en su lugar las rutinas de manejo de memoria devolvían un puntero al puntero - referido como un asa . En consecuencia, para acceder a cualquier parte de la memoria asignada, era necesario desreferenciar el asa dos veces. Tomó un tiempo, pero la práctica constante finalmente llevó la lección a casa.

El manejo del puntero de Pascal es más fácil de comprender que C ++, donde la sintaxis no ayuda al principiante. Si realmente está atrapado entendiendo punteros en C, entonces su mejor opción podría ser obtener una copia de un compilador de Pascal e intentar escribir algún código de puntero básico en él (Pascal está lo suficientemente cerca de C obtendrá los conceptos básicos en unas pocas horas). ) Las listas enlazadas y similares serían una buena opción. Una vez que te sientas cómodo con los que regresan a C ++ y con los conceptos dominados, encontrarás que el acantilado no se verá tan escarpado.

0
agregado

Los punteros ya parecen abordarse (sin juego de palabras) en otras respuestas.

Las clases son fundamentales para OO. Tuve tremendos problemas para convertir mi cabeza en OO, diez años de intentos fallidos. El libro que finalmente me ayudó fue "Aplicación de UML y patrones" de Craig Larman. Sé que suena como si se tratara de algo diferente, pero realmente hace un gran trabajo al facilitarte en el mundo de las clases y los objetos.

0
agregado

This link has a video describing how pointers work, with claymation. Informative, and easy to digest.

This page has some good information on the basic of classes.

0
agregado
Cualquier cosa con claymation obtiene un +1 en mi libro.
agregado el autor Aardvark, fuente

El mejor libro que he leído sobre estos temas es Thinking in C ++ de Bruce Eckel. Puede descargarlo de forma gratuita aquí .

0
agregado
gracias el libro descargado viene con muchos ejemplos
agregado el autor timmyg, fuente

Las clases son relativamente fáciles de entender; OOP puede llevarle muchos años. Personalmente, no entendí completamente la POO verdadera hasta el año pasado. Es una pena que Smalltalk no esté tan extendido en las universidades como debería ser. Realmente lleva a casa el punto de que OOP trata de objetos que intercambian mensajes, en lugar de que las clases sean variables globales autónomas con funciones.

Si realmente eres nuevo en las clases, entonces el concepto puede tomar un tiempo para comprenderlo. Cuando los encontré por primera vez en el 10 ° grado, no lo conseguí hasta que tuve a alguien que sabía lo que estaban haciendo, paso por el código y explica lo que estaba pasando. Eso es lo que sugiero que intentes.

0
agregado

En cierto sentido, puede considerar "punteros" como uno de los dos tipos más fundamentales de software, el otro como "valores" (o "datos") que existen en un gran bloque de ubicaciones de memoria direccionables de manera única. Piénsalo. Los objetos y las estructuras, etc., realmente no existen en la memoria, solo los valores y punteros lo hacen. De hecho, un puntero también es un valor ... el valor de una dirección de memoria, que a su vez contiene otro valor ... y así sucesivamente.

So, in C/C++, when you declare an "int" (intA), you are defining a 32bit chunk of memory that contains a value - a number. If you then declare an "int pointer" (intB), you are defining a 32bit chunk of memory that contains the address of an int. I can assign the latter to point to the former by stating "intB = &intA", and now the 32bits of memory defined as intB, contains an address corresponding to intA's location in memory.

Cuando "desreferencia" el puntero intB, está mirando la dirección almacenada en la memoria del intB, buscando esa ubicación y luego mirando el valor almacenado allí (un número).

Commonly, I have encountered confusion when people lose track of exactly what it is they're dealing with as they use the "&", "*" and "->" operators - is it an address, a value or what? You just need to keep focused on the fact that memory addresses are simply locations, and that values are the binary information stored there.

0
agregado

Los punteros y las clases no son realmente temas avanzados en C ++. Ellos son bastante fundamentales.

Para mí, los indicadores se solidificaron cuando comencé a dibujar cajas con flechas. Dibuja un cuadro para un int. Y int * ahora es un cuadro separado con una flecha que apunta al cuadro int.

Asi que:

int foo = 3;          //integer
int* bar = &foo;      //assigns the address of foo to my pointer bar

Con el cuadro de mi puntero (barra), tengo la opción de mirar la dirección dentro del cuadro. (Que es la dirección de memoria de foo). O puedo manipular cualquier cosa que tenga una dirección. Esa manipulación significa que estoy siguiendo esa flecha al entero (foo).

*bar = 5; //asterix means "dereference" (follow the arrow), foo is now 5
bar = 0;  //I just changed the address that bar points to

Las clases son otro tema completamente. Hay algunos libros sobre diseño orientado a objetos, pero no sé cuáles son buenos para los principiantes de la parte superior de mi cabeza. Podrías tener suerte con un libro introductorio de Java.

0
agregado
bueno, son temas avanzados para mí, jaja, entiendo tus ejemplos aquí, pero cuando trato de entender el código de otra persona no puedo entenderlo ... tal vez solo necesito más experiencia ... gracias por la respuesta.
agregado el autor timmyg, fuente
Secundo esto. Para los principiantes, SIEMPRE traduzca "puntero" a "dirección" y "desreferencia" a "viajar a la dirección", como conducir un automóvil. los punteros a punteros se convierten en casillas de correo de reenvío: direcciones que, cuando vayas allí, encuentras otra dirección en lugar de una ubicación de almacenamiento.
agregado el autor Aaron, fuente
Es posible que gran parte de ese código no esté muy bien escrito. Una vez pasé una cantidad significativa de tiempo tratando de averiguar cómo funcionaba algún código de puntero pesado. Me rendí y le pregunté a un superior. Lo miró durante 2 segundos y dijo "Huh. Eso va a causar un choque. Mejor arreglarlo". Experiencia: la capacidad de mirar un espécimen, verlo hacer algo extraño, y pensar "Hay algo mal con esto" en lugar de "Hay algo mal conmigo".
agregado el autor deworde, fuente

Comprender los indicadores en C/C ++

Antes de que uno pueda entender cómo funcionan los punteros, es necesario comprender cómo se almacenan y se accede a las variables en los programas. Cada variable tiene 2 partes: (1) la dirección de memoria donde se almacenan los datos y (2) el valor de los datos almacenados.

La dirección de la memoria a menudo se denomina valor l de una variable, y el valor de los datos almacenados se conoce como el valor r (l y r significan izquierda y derecha).

Considera la declaración:

int x = 10;

Internamente, el programa asocia una dirección de memoria con la variable x. En este caso, supongamos que el programa asigna x para residir en la dirección 1001 (no es una dirección realista, sino que se elige por simplicidad). Por lo tanto, el lvalue (dirección de memoria) de x es 1001, y el valor r (valor de datos) de x es 10.

The rvalue is accessed by simply using the variable “x”. In order to access the lvalue, the “address of” operator (‘&’) is needed. The expression ‘&x’ is read as "the address of x".

Expression          Value
----------------------------------
x                   10
&x                  1001

The value stored in x can be changed at any time (e.g. x = 20), but the address of x (&x) can never be changed.

Un puntero es simplemente una variable que se puede usar para modificar otra variable. Lo hace teniendo una dirección de memoria para su valor r. Es decir, apunta a otra ubicación en la memoria.

La creación de un puntero a "x" se realiza de la siguiente manera:

int* xptr = &x;

The “int*” tells the compiler that we are creating a pointer to an integer value. The “= &x” part tells the compiler that we are assigning the address of x to the rvalue of xptr. Thus, we are telling the compiler that xptr “points to” x.

Suponiendo que xptr está asignado a una dirección de memoria de 1002, entonces la memoria del programa podría verse así:

Variable    lvalue    rvalue
--------------------------------------------
x           1001      10   
xptr        1002      1001

La siguiente pieza del rompecabezas es el "operador indirecto" ('*'), que se utiliza de la siguiente manera:

int y = *xptr;

El operador indirecto le dice al programa que interprete el valor r de xptr como una dirección de memoria en lugar de un valor de datos. Es decir, el programa busca el valor de datos (10) almacenado en la dirección proporcionada por xptr (1001).

Poniendolo todo junto:

Expression      Value
--------------------------------------------
x                   10
&x                  1001
xptr                1001
&xptr               1002
*xptr               10

Ahora que los conceptos han sido explicados, aquí hay un código para demostrar el poder de los punteros:

int x = 10;
int *xptr = &x;

printf("x = %d\n", x);
printf("&x = %d\n", &x);        
printf("xptr = %d\n", xptr);
printf("*xptr = %d\n", *xptr);

*xptr = 20;

printf("x = %d\n", x);
printf("*xptr = %d\n", *xptr);

Para la salida, verá (Nota: la dirección de la memoria será diferente cada vez):

x = 10
&x = 3537176
xptr = 3537176
*xptr = 10
x = 20
*xptr = 20

Notice how assigning a value to ‘*xptr’ changed the value of ‘x’. This is because ‘*xptr’ and ‘x’ refer to the same location in memory, as evidenced by ‘&x’ and ‘xptr’ having the same value.

0
agregado
gracias por la respuesta muy útil
agregado el autor timmyg, fuente
lvalues ​​y rvalues ​​no tienen nada que ver con las direcciones de memoria.
agregado el autor Puppy, fuente

The book that cracked pointers for me was Illustrating Ansi C by Donald Alcock. Its full of hand-drawn-style box and arrow diagrams that illustrate pointers, pointer arithmetic, arrays, string functions etc...

Obviamente es un libro 'C', pero para los fundamentos básicos es difícil de superar

0
agregado

Una de las cosas que realmente me ayudó a entender estos conceptos es aprender UML, el lenguaje de modelado unificado. Ver conceptos de diseño orientado a objetos en un formato gráfico realmente me ayudó a aprender lo que significan. A veces, tratar de comprender estos conceptos simplemente observando qué código fuente los implementa puede ser difícil de comprender.

Ver paradigmas orientados a objetos como la herencia en forma gráfica es una forma muy poderosa de captar el concepto.

La UML Distilled de Martin Fowler es una buena y breve introducción.

0
agregado

No hay substiture para practicar.

Es fácil leer un libro o escuchar una conferencia y sentir que estás siguiendo lo que está pasando.

Lo que recomendaría es tomar algunos de los ejemplos de código (supongo que los tiene en algún lugar del disco), compilarlos y ejecutarlos, luego intente cambiarlos para hacer algo diferente.

  • Agregue otra subclase a una jerarquía
  • Agregue un método a una clase existente
  • Cambiar un algoritmo que itera reenviar a través de una colección para ir hacia atrás en su lugar.

No creo que haya ningún libro de "bala de plata" que lo haga.

Para mí, lo que me llevó a casa lo que los punteros significaban era trabajar en ensamblaje, y ver que un puntero era en realidad solo una dirección, y que tener un puntero no significaba que lo que apuntaba era un objeto significativo.

0
agregado

Para punteros y clases, aquí está mi analogía. Usaré una baraja de cartas. El mazo de cartas tiene un valor nominal y un tipo (9 de corazones, 4 de picas, etc.). Entonces en nuestro lenguaje de programación C ++ de "Deck of Cards" diremos lo siguiente:

HeartCard card = 4;//4 of hearts!

Ahora, sabes dónde está el 4 de corazones porque, por suerte, estás sosteniendo el mazo, boca arriba en la mano, ¡y está en la parte superior! Entonces, en relación con el resto de las cartas, diremos que el 4 de corazones está al COMIENZO. Entonces, si te pregunté qué carta es al COMIENZO, dirías, "¡El 4 de corazones por supuesto!". Bueno, simplemente me "apuntó" hacia donde está la tarjeta. En nuestro lenguaje de programación "Deck of Cards", puede decir lo siguiente:

HeartCard card = 4;//4 of hearts!
print &card//the address is BEGINNING!

Ahora, dale la vuelta a tu mazo de cartas. La parte de atrás ahora está COMENZANDO y usted no sabe lo que es la tarjeta. Pero, digamos que puedes hacer lo que quieras porque estás lleno de magia. Hagámoslo en nuestro langauge "Deck of Cards".

HeartCard *pointerToCard = MakeMyCard( "10 of hearts" );
print pointerToCard//the value of this is BEGINNING!
print *pointerToCard//this will be 10 of hearts!

Bueno, MakeMyCard ("10 de corazones") estaba haciendo tu magia y sabiendo que querías apuntar a COMENZAR, ¡haciendo de la carta un 10 de corazones! Le das la vuelta a tu tarjeta y, ¡voilá! Ahora, el * puede tirarte. Si es así, mira esto:

HeartCard *pointerToCard = MakeMyCard( "10 of hearts" );
HeartCard card = 4;//4 of hearts!
print *pointerToCard;//prints 10 of hearts
print pointerToCard;//prints BEGINNING
print card;//prints 4 of hearts
print &card;//prints END - the 4 of hearts used to be on top but we flipped over the deck!

En cuanto a las clases, hemos estado usando clases en el ejemplo definiendo un tipo como HeartCard. Sabemos lo que es una HeartCard ... ¡Es una tarjeta con un valor y un tipo de corazón! Entonces, hemos clasificado eso como una HeartCard. Cada idioma tiene una forma similar de definir o "clasificar" lo que desea, ¡pero todos comparten el mismo concepto! Espero que esto haya ayudado ...

0
agregado
Esa fue una analogía bastante pésima.
agregado el autor FlySwat, fuente

Pointers are not some sort of magical stuff, you're using them all the time!
When you say:

int a;

and the compiler generates storage for 'a', you're practically saying that you're declaring
an int and you want to name its memory location 'a'.

When you say:

int *a;

estás declarando una variable que puede contener una ubicación de memoria de un int. Es así de simple. Además, no tengas miedo de la aritmética de puntero, solo siempre tenga en mente un "mapa de memoria" cuando trate con punteros y piense en términos de caminar a través de direcciones de memoria.

Las clases en C ++ son solo una forma de definir tipos de datos abstractos. Sugiero leer un buen libro OOP para entender el concepto, entonces, si está interesado, aprenda cómo los compiladores C ++ generan código para simular OOP. Pero este conocimiento llegará a tiempo, si te quedas con C ++ lo suficiente :)

0
agregado

Your problem seems to be the C core in C++, not C++ itself. Get yourself the Kernighan & Ritchie (The C Programming Language). Inhale it. It's very good stuff, one of the best programming language books ever written.

0
agregado

En el caso de las clases, tuve tres técnicas que realmente me ayudaron a dar el salto a la programación orientada a objetos reales.

El primero fue que trabajé en un proyecto de juego que hizo un uso intensivo de clases y objetos, con uso intensivo de generalización (tipo de relación o es, una clase, por ejemplo, el estudiante es un tipo de persona) y composición (tiene una relación, ex. estudiante tiene un préstamo estudiantil). Romper este código tomó mucho trabajo, pero realmente trajo las cosas en perspectiva.

The second thing that helped was in my System Analysis class, where I had to make http://www.agilemodeling.com/artifacts/classDiagram.htm">UML class diagrams. These I just really found helped me understand the structure of classes in a program.

Por último, ayudo a los estudiantes de mi universidad en la programación. Todo lo que puedo decir sobre esto es que aprendes mucho enseñando y viendo el enfoque de otras personas ante un problema. Muchas veces un estudiante intentará cosas que nunca hubiera pensado, pero que generalmente tienen mucho sentido y simplemente tienen problemas para implementar su idea.

Mi mejor consejo es que requiere mucha práctica, y cuanto más programes, mejor lo entenderás.

0
agregado