En C++ no puedo entender los indicadores y las clases

Question

Estoy recién egresado de la universidad y llevo trabajando en C++ desde hace algún 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 conceptos de clase? o tal vez algún código de ejemplo con buenos comentarios descriptivos utilizando punteros avanzados y técnicas de clase? cualquier ayuda sería muy apreciada.

Answer 1

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 excesiva gráfico, pero en su mayor parte, siempre y cuando no quiere saber lo que el número es o configurarlo manualmente que debe estar bien.

Cuando entendí C tenía unas 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 que por sí sola no es útil. Con suerte, alguien más puede ampliar esa lógica.

Answer 2

para los punteros:

encontré this post tenían discusión muy reflexivo acerca de los punteros. Quizás eso ayude. ¿Estás familiarizado con refrences como en C#? Eso es algo que realmente se refiere a 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.

Answer 3

Solía ​​tener un problema para entender los punteros en pascal way back :) 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.

Answer 4

Para entender los punteros, no puedo recomendar el libro K&R lo suficiente.

Answer 5

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

Answer 6

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 acerca de lo que los punteros son es el siguiente:

1. crear una lista vinculada
2. iterar a través de él de principio a fin
3. invertirla para que la cabeza es ahora la parte de atrás y la parte posterior ahora es la cabeza

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

Answer 7

This link tiene un video que describe cómo funcionan los punteros, con claymation. Informativo y fácil de digerir.

This page tiene algo de buena información sobre el básico de las clases.

Answer 8

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

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

Así:

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

con la caja de mi puntero (bar) que tienen la opción de buscar en la dirección dentro de la caja. (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 diferente. 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.

Answer 9

Para las clases:

El momento breakthru para mí fue cuando supe acerca de las 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 nos dijo explícitamente 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 permiten que se coloca encima de la funcionalidad y la llama de una manera más limpia (la mayoría de las veces, siempre hay excepciones)

Answer 10

El libro que se quebró punteros para mí fue Illustrating Ansi C por Donald Alcock. Está llena de caja y de dirección diagramas de estilo dibujado a mano que ilustran punteros, la aritmética de punteros, arrays, funciones de cadena, etc ...

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

Answer 11

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.

Martin Fowler's UML Distilled es una buena y breve introducción.

Answer 12

De la respuesta de lassevek a un similar question on SO:

punteros es un concepto que para muchos puede ser confuso al principio, en particular, cuando se trata de la copia de valores de puntero alrededor y todavía referencia a la misma memoria bloquear.

He encontrado que la mejor analogía es consideran el puntero como un pedazo de papel con un dirección de casa en ella, y el bloque de memoria se hace referencia a que la casa real . Todo tipo de operaciones este modo se pueden explicar fácilmente:

• Copiar valor del puntero, acaba de escribir la dirección en una nueva hoja de papel
• Las listas enlazadas, hoja de papel en la casa con la dirección de la siguiente casa en ella
• liberar la memoria, demoler la casa y borrar la dirección
• Pérdida de memoria, se pierde la hoja de papel y no puede encontrar la casa
• liberar la memoria, pero manteniendo una referencia (ahora no válido), demoler el casa, borrar uno de los trozos de papel pero tienen otra hoja de papel con la dirección antigua en ella, cuando ir a la dirección, no encontrará una casa , pero es posible encontrar algo que se asemeja a las ruinas de una saturación del búfer
• , se mueven más cosas en la casa de lo que puede posiblemente en forma, se derrama en la casa vecinos

Answer 13

Para entender mejor punteros, creo, puede ser útil para ver 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.

Puede leer Inside the C++ Object Model si desea obtener una mejor comprensión de lo que hay debajo del modelo de objetos C++.

Answer 14

Los apuntadores ya parecen estar dirigidos (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.

Answer 15

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 cambie 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.

En estos días, si un compilador no puede optimizar una operación de matriz mejor que puede utilizar punteros, su compilador está roto.

Por favor, no me malinterpreten, no digo C++ es horrible o algo así y no quiero iniciar una discusión de incidencia, lo he usado y lo uso ocasionalmente ahora, solo te estoy recomendando comienza con otra cosa.

Realmente NO es como aprender a conducir 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 automóvil - Entonces te encuentras manejando tu auto en el medio de la calle a 5 mph con las luces de emergencia encendidas.

[edit] revisando el último párrafo - ¡Creo que esa puede haber sido la analogía más precisa de mi historia!

Answer 16

Aprenda el lenguaje ensamblador y luego aprenda C. Entonces sabrá 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.

Answer 17

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 lástima 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.

Answer 18

No hay substitutos para practicar.

Es fácil de leer a través de 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.

• Añadir otra subclase de una jerarquía
• Añadir un método de una clase existente
• Cambiar un algoritmo que itera adelante a través de una colección de ir hacia atrás en 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 viendo 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.

Answer 19

El punto en el que realmente obtuve punteros fue codificando TurboPascal en un FatMac (alrededor de 1984 más o menos) - que era el lenguaje Mac nativo en ese momento. El Mac tenía un modelo de memoria impar según 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 las rutinas de manejo de memoria devolvían un puntero al puntero. como un mango. 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.

Answer 20

En cierto sentido, puede considerar "punteros" como uno de los dos tipos más fundamentales de software; el otro son los "valores" (o "datos") que existen en un gran bloque de memoria direccionable de manera única. ubicaciones. 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.

Por lo tanto, en C/C++, cuando declara un "int" (intA), está definiendo un fragmento de 32 bits de memoria que contiene un valor, un número. Si luego declara un "puntero int" (intB), está definiendo un fragmento de 32 bits de memoria que contiene la dirección de un int. Puedo asignar este último para que apunte al primero indicando "intB = & intA", y ahora los 32 bits de memoria definidos como intB, contienen una dirección correspondiente a la ubicación de intA en la memoria.

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

Comúnmente, he encontrado confusión cuando las personas pierden de vista exactamente qué es lo que están tratando, ya que utilizan los operadores "&", "*" y "->" - ¿es una dirección, un valor o ¿Qué? Solo necesita mantenerse enfocado en el hecho de que las direcciones de memoria son simplemente ubicaciones, y que los valores son la información binaria almacenada allí.

Answer 21

¿Has leído Bjarne Stroustrup's The C++ Programming Language? Él creó C++.

La C++ FAQ Lite también es buena.

Answer 22

Para punteros y clases, esta es 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.). Así que en nuestro C++ como lenguaje de programación de "Cubierta de tarjetas" vamos a decir lo siguiente:

HeartCard card = 4; // 4 of hearts! 

Ahora, usted sabe que el 4 de corazones es porque mira por dónde, que está sosteniendo la cubierta, boca arriba en tu mano, ¡y está en la cima! 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 "Cubierta de tarjetas", usted podría decir también lo siguiente:

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

Ahora, a su vez su baraja de cartas más. 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") era que hacer su magia y sabiendo que quería señalar al principio, porque de la tarjeta 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, que hemos estado usando las clases en el ejemplo mediante la definición de un tipo que 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 ...

Answer 23

Puede encontrar este article by Joel instructivo. 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 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 en 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 muy buena lectura (si no un poco gruesa y concisa en algunos puntos).

Answer 24

Entendiendo Punteros en C/C++

Antes de que uno pueda comprender cómo funcionan los punteros, es necesario entender cómo se almacenan y se accede en los programas de las variables. 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 memoria a menudo se conoce como el valor l de una variable, y el valor de los datos almacenados se conoce como el valor r (l y r que significa izquierda y derecha).

considerar 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.

Se accede al valor r simplemente con la variable "x". Para acceder al valor l, se necesita el operador "dirección de" ('&'). La expresión '& x' se lee como "la dirección de x".

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

El valor almacenado en x se puede cambiar en cualquier momento (por ejemplo, x = 20), pero la dirección de x (& x) no se puede cambiar.

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.

Creación de un puntero a “x” se realiza de la siguiente manera:

int* xptr = &x; 

El “int *” indica al compilador que estamos creando un puntero a un valor entero. La parte "= & x" le dice al compilador que estamos asignando la dirección de x al valor r de xptr. Por lo tanto, le estamos diciendo al compilador que xptr "apunta a" x.

Suponiendo que xptr se asigna a una dirección de memoria de 1002, a continuación, la memoria del programa podría tener este aspecto:

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

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

int y = *xptr; 

el operador de indirección le dice al programa para interpretar el valor de lado derecho 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).

Poniendo todo junto:

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

Ahora que los conceptos se han explicado, he aquí algo de código para demostrar el poder de 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 se podría ver (Nota: la dirección de la memoria será diferente cada vez):

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

Observe cómo asignar av alue to '* xptr' cambió el valor de 'x'. Esto se debe a que '* xptr' y 'x' hacen referencia a la misma ubicación en la memoria, como lo demuestran '& x' y 'xptr' con el mismo valor.

Answer 25

Los apuntadores no son un tipo de cosas mágicas, ¡las estás usando todo el tiempo!
Cuando diga:

int a;

y el compilador genera almacenamiento para 'a', prácticamente está diciendo que está declarando
un int y desea ponerle nombre a su ubicación de memoria 'a'.

Cuando dicen:

int * a;

está declarando una variable que puede contener una ubicación de memoria de un int. Es así de simple. Además, no tenga miedo acerca de la aritmética de puntero, solo siempre tenga en cuenta un "mapa de memoria" cuando se trata de punteros y piense en términos de caminando 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 :)

Answer 26

Tu problema parece ser el núcleo C en C++, no C++ en sí. Obtenga el Kernighan & Ritchie (The C Programming Language). Inhalalo. Es muy bueno, uno de los mejores libros de lenguaje de programación jamás escritos.

Answer 27

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.

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

Lo segundo que me ayudó fue en mi clase de análisis del sistema, donde tuve que hacer http://www.agilemodeling.com/artifacts/classDiagram.htm">gramas de clase deUML. Estos descubrí que realmente me ayudaron a entender la estructura de las clases en un programa.

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. 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 se necesita mucha práctica, una Cuanto más programes, mejor lo entenderás.