Em C ++ não consigo agarrar ponteiros e classes

Estou recém-saído da faculdade e trabalho em C ++ há algum tempo. Eu entendo todos os conceitos básicos do C ++ e os uso, mas estou tendo dificuldade em entender tópicos mais avançados, como ponteiros e classes. Eu li alguns livros e tutoriais e eu entendo os exemplos neles, mas quando eu olho para alguns exemplos avançados da vida real eu não consigo descobri-los. Isso está me matando porque eu sinto que isso me impede de trazer minha programação C ++ para o próximo nível. Alguém mais teve esse problema? Se sim, como você quebrou isso? Alguém sabe de algum livro ou tutorial que realmente descreve os ponteiros e os conceitos de classe? ou talvez algum código de exemplo com bons comentários descritivos usando ponteiros avançados e técnicas de classe? Qualquer ajuda seria muito apreciada.

0
adicionado editado
Visualizações: 11
FYI, ponteiros e classes SÃO os fundamentos do C ++.
adicionado o autor Wedge, fonte
P.S. C ++ é uma linguagem muito rica e ampla. Se você não consegue entender exemplos avançados, isso não significa necessariamente que você está perdendo alguma coisa (o buraco "coelho" avançado em C ++ é muito, muito profundo). Ajudaria se você fornecesse informações mais específicas.
adicionado o autor Wedge, fonte
Deixe-me adivinhar: você está escrevendo um código matemático computacional e sua falta de compreensão de ponteiros atrapalha o processamento de dados multidimensionais. Fechar?
adicionado o autor Arkadiy, fonte
Muitas das respostas foram muito boas. Muito obrigado a todos que responderam. Vou seguir algumas respostas, mas parece que eu só preciso ficar com ela e ter mais experiência.
adicionado o autor timmyg, fonte
Eu tentei deixar claro na minha pergunta, mas talvez eu não tenha compreendido os ponteiros e as aulas em termos de lições e exemplos de livros didáticos. Mas quando eu preciso ler e entender o código de outra pessoa, por exemplo, uma API de software, com ponteiros e classes é onde eu tenho dificuldade em entender.
adicionado o autor timmyg, fonte
Como exatamente você trabalha com C ++ por algum tempo sem esse conhecimento ...? C ++ w/o classes soa como C, e C w/o ponteiros soa como um .....
adicionado o autor Aardvark, fonte
Você não conhece um pouco de C ++ se não entender o conceito de classes. E se você não entender os ponteiros, então provavelmente você não sabe C ...
adicionado o autor FlySwat, fonte
Por curiosidade, que idiomas você aprendeu na faculdade? Além de linguagens funcionais puras, não consigo pensar em idiomas que não possuam ponteiros ou classes.
adicionado o autor David Locke, fonte

27 Respostas

Para entender melhor os ponteiros, acho que pode ser útil observar como a linguagem assembly funciona com ponteiros. O conceito de ponteiros é realmente uma das partes fundamentais da arquitetura assembly e da arquitetura de processador x86. Talvez isso deixe você se sentir como ponteiros são uma parte natural de um programa.

Quanto às classes, além do paradigma OO, acho que pode ser interessante ver as classes de uma perspectiva binária de baixo nível. Eles não são tão complexos a esse respeito no nível 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
adicionado

Você pode encontrar este artigo de Joel instrutivo. Como um aparte, se você tem "trabalhado em C ++ por algum tempo" e se formado em CS, você pode ter ido para um JavaSchool (eu diria que você não tem trabalhado em C ++, você tem trabalhando em C, mas usando o compilador C ++).

Além disso, apenas para secundar as respostas de hojou e nsanders, os ponteiros são muito fundamentais para o C ++. Se você não entende ponteiros, então você não entende o básico do C ++ (reconhecer este fato é o começo do entendimento do C ++, a propósito). Da mesma forma, se você não entender as classes, não entenderá o básico do C ++ (ou OO).

Para os ponteiros, acho que desenhar com caixas é uma boa ideia, mas trabalhar na montagem também é uma boa ideia. Quaisquer instruções que usem o endereçamento relativo farão com que você entenda quais ponteiros são mais rápidos, eu acho.

Quanto às classes (e programação orientada a objeto mais geralmente), eu recomendaria Stroustrups "A linguagem de programação C ++" última edição. Não só é o material de referência C ++ canônico, mas também tem bastante material em muitas outras coisas, desde hierarquias de classes orientadas a objetos básicas e herança até princípios de design em grandes sistemas. É uma leitura muito boa (se não for um pouco grossa e concisa em alguns pontos).

0
adicionado
lol, eu acabei de ler o artigo de Joel e foi isso que me fez vir aqui e procurar por perguntas sobre ponteiros.
adicionado o autor Spidey, fonte

Aprenda a linguagem assembly e depois aprenda C. Então você saberá quais são os princípios subjacentes da máquina (e os primeiros ponteiros).

Ponteiros e classes são aspectos fundamentais do C ++. Se você não os entende, significa que você não entende realmente o C ++.

Pessoalmente, retive o C ++ por vários anos, até que senti que tinha uma compreensão firme de C e o que estava acontecendo sob o capô em linguagem assembly. Embora isso tenha sido há muito tempo, acho que realmente beneficiou minha carreira entender como o computador funciona em um nível baixo.

Aprender a programar pode levar muitos anos, mas você deve ficar com ela porque é uma carreira muito gratificante.

0
adicionado

Da resposta de lassevek a uma pergunta semelhante sobre SO :

Ponteiros é um conceito que para muitos   pode ser confuso no início, em   em particular quando se trata de copiar   valores de ponteiro ao redor e ainda   referenciando o mesmo bloco de memória.

     

Eu descobri que a melhor analogia é   considere o ponteiro como um pedaço de   papel com um endereço de casa, e   o bloco de memória se refere como o   casa real. Todos os tipos de operações   pode assim ser facilmente explicado:

     
      
  • Copiar o valor do ponteiro, basta escrever o endereço em um novo pedaço de papel
  •   
  • Listas vinculadas, pedaço de papel na casa com o endereço do próximo   casa nele
  •   
  • Liberando a memória, demolindo a casa e apagando o endereço
  •   
  • Fuga de memória, você perde o pedaço de papel e não consegue encontrar a casa
  •   
  • Liberando a memória, mas mantendo uma referência (agora inválida), demole o   casa, apague um dos pedaços de   papel, mas tem outro pedaço de papel   com o endereço antigo, quando você   vá para o endereço, você não encontrará   casa, mas você pode encontrar algo   que se assemelha às ruínas de um
  •   
  • Buffer overrun, você move mais coisas para dentro da casa do que consegue   possivelmente se encaixam, derramando no   casa dos vizinhos
  •   
0
adicionado

Ponteiros e classes são tópicos completamente diferentes, então eu não os colocaria juntos assim. Dos dois, eu diria que os ponteiros são mais fundamentais.

Um bom exercício para aprender sobre quais ponteiros são os seguintes:

  1. crie uma lista vinculada
  2. iterar do começo ao fim
  3. inverta-o de modo que a cabeça esteja agora nas costas e as costas estejam agora na cabeça

Faça tudo em um quadro branco primeiro. Se você puder fazer isso facilmente, não terá mais problemas para entender quais são os ponteiros.

0
adicionado

Nós estávamos discutindo alguns aspectos de C ++ e OO na hora do almoço, alguém (um grande engenheiro, na verdade) estava dizendo que, a menos que você tenha um histórico de programação realmente forte antes de aprender C ++, isso literalmente arruinará você.

Eu recomendo aprender primeiro outro idioma, depois mudar para o C ++ quando você precisar dele. Não é como se houvesse algo de bom em ponteiros, eles são simplesmente uma parte vestigial remanescente de quando era difícil para uma operação de conversão de compilador montar-se eficientemente sem eles.

Hoje em dia, se um compilador não pode otimizar uma operação de matriz melhor, então você pode usar ponteiros, seu compilador está quebrado.

Por favor, não me entenda mal, eu não estou dizendo que o C ++ é horrível ou qualquer coisa e não quero começar uma discussão de advocacy, eu usei e usei ocasionalmente agora, eu só estou recomendando que você comece com algo mais .

Não é como aprender a dirigir um carro manual e depois aplicá-lo facilmente a um automático, é mais como aprender a dirigir em um desses enormes guindastes de construção, assumindo que isso será aplicado quando você começar a dirigir um carro - então você encontre-se dirigindo o seu carro no meio da rua a 5mph com as luzes de emergência acesas.

[editar] revendo esse último parágrafo - Eu acho que essa pode ter sido a minha analogia mais precisa de todas!

0
adicionado
Algum idioma que você sugerir aprender primeiro? python seria uma boa escolha? Atualmente estou tentando aprender PHP, bem como c + +, sintaxe sábio eles são muito semelhantes.
adicionado o autor timmyg, fonte
Ah, e se você realmente quiser aprender conceitos de programação inovadores, veja o Scala. Honestamente, isso pode ser o melhor por causa de todos os conceitos que você expõe imediatamente. Hascal e Lisp também são conhecidos por ensinar bons conceitos de programação.
adicionado o autor Bill K, fonte
C # e Java são bons porque são verificados em tempo de compilação e honestamente é um bom hábito para entrar. Se você quer apenas brincar, o Python é bom. Se você está fazendo um site, ruby on Rails - period.
adicionado o autor Bill K, fonte

Eu costumava ter um problema de entender ponteiros no pascal muito tempo atrás :) Uma vez eu comecei a fazer ponteiros assembler foi realmente a única maneira de acessar a memória e ele só me bateu. Pode soar como um tiro distante, mas experimentar o montador (que é sempre uma boa idéia tentar entender o que os computadores realmente são) provavelmente lhe ensinará ponteiros. Aulas - bem, eu não entendo o seu problema - foi sua programação puramente estruturada de escolaridade? Uma classe é apenas uma maneira lógica de olhar para os modelos da vida real - você está tentando resolver um problema que pode ser resumido em vários objetos/classes.

0
adicionado

Para ponteiros:

Eu encontrei este post teve uma discussão muito cuidadosa sobre os ponteiros. Talvez isso ajude. Você está familiarizado com referências como em c #? Isso é algo que realmente se refere para outra coisa? Isso é provavelmente um bom começo para entender os ponteiros.

Além disso, veja abaixo o post de Kent Fredric sobre outra maneira de se apresentar aos ponteiros.

0
adicionado

Para as aulas:

O momento decisivo para mim foi quando aprendi sobre interfaces. A ideia de abstrair os detalhes de como você escreveu resolveu um problema, e dar apenas uma lista de métodos que interagem com a classe foi muito perspicaz.

De fato, meu professor explicitamente nos disse que classificaria nossos programas conectando nossas aulas ao seu equipamento de teste. A classificação seria feita com base nos requisitos que ele nos deu e se o programa falhou.

Para encurtar a história, as classes permitem que você envolva a funcionalidade e chame-a de maneira mais clara (na maioria das vezes, sempre há exceções)

0
adicionado
Um equipamento de teste é um código que exerce outro conjunto de códigos. Meu professor basicamente tinha um programa principal que chamava funções em nossa classe. Ele executaria o teste, marcaria uma nota, excluiria seu arquivo e inseriria o próximo arquivo de alunos em sua solução e repetiria todo o processo.
adicionado o autor Jason Z, fonte
o que é um "arnês de teste"?
adicionado o autor DarenW, fonte

Finja que um ponteiro é um endereço de matriz.

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

é uma simplificação gráfica, mas na maior parte do tempo, desde que você nunca queira saber o que é esse número ou configurá-lo manualmente, você deve estar bem.

Quando eu entendia C, eu tinha algumas macros que permitiam mais ou menos usar ponteiros como se fossem um índice de array na memória. Mas há muito tempo que perdi esse código e há muito esqueci.

Eu me lembro que começou com

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

e isso por si só é pouco útil. Espero que alguém possa expandir essa lógica.

0
adicionado
Sim, eu não entendo, acho que essa é uma ótima maneira de entender os ponteiros. Arrays são mais fáceis de entender do que ponteiros, IMO, então eu acho que é um ótimo ponto de partida.
adicionado o autor Doug T., fonte
Eu acho que isso é muito útil. Em muitos sistemas embarcados eu não tinha um ponteiro para as coisas alocadas para mim, eu tinha um índice de array :).
adicionado o autor Doug T., fonte
para aqueles de vocês me rebaixando para este post, funciona. Eu usei, ajudei outros com isso. O fato de que o sistema operacional abstrai tudo isso para você não é importante para o exercício.
adicionado o autor Kent Fredric, fonte

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

0
adicionado

Você leu A Linguagem de Programação em C ++ de Bjarne Stroustrup ? Ele criou o C ++.

O C ++ FAQ Lite também é bom.

0
adicionado

O ponto em que eu realmente recebi dicas foi codificando o TurboPascal em um FatMac (por volta de 1984) - que era a linguagem Mac nativa na época.

O Mac tinha um modelo de memória ímpar em que quando alocado o endereço a memória era armazenada em um ponteiro no heap, mas a localização do mesmo não era garantida e em vez disso as rotinas de manipulação de memória retornavam um ponteiro para o ponteiro - referido como um identificador . Consequentemente, para acessar qualquer parte da memória alocada, era necessário cancelar a referência do identificador duas vezes. Demorou um pouco, mas a prática constante levou a lição para casa.

O manuseio de ponteiros de Pascal é mais fácil de entender que o C ++, onde a sintaxe não ajuda o iniciante. Se você está realmente e verdadeiramente preso ponteiros compreensão em C, então sua melhor opção pode ser para obter uma cópia aa compilador Pascal e tentar escrever algum código ponteiro básico nele (Pascal está perto o suficiente para C você vai ter o básico em poucas horas ). Listas vinculadas e afins seriam uma boa escolha. Uma vez que você esteja confortável com aqueles que retornam ao C ++ e com os conceitos dominados, você descobrirá que o penhasco não parecerá tão íngreme.

0
adicionado

Ponteiros já parecem ser abordados (sem trocadilhos) em outras respostas.

Classes são fundamentais para OO. Eu tive um tremendo problema em arrancar minha cabeça em OO - como, dez anos de tentativas fracassadas. O livro que finalmente me ajudou foi "Aplicando UML e Padrões" de Craig Larman. Eu sei que soa como se fosse algo diferente, mas realmente faz um ótimo trabalho de facilitar você no mundo de classes e objetos.

0
adicionado

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
adicionado
Qualquer coisa com claymation ganha +1 no meu livro.
adicionado o autor Aardvark, fonte

O melhor livro que eu li sobre esses tópicos é Pensando em C ++ por Bruce Eckel. Você pode baixá-lo gratuitamente aqui .

0
adicionado
obrigado o livro baixado vem com muitos exemplos
adicionado o autor timmyg, fonte

As aulas são relativamente fáceis de entender; OOP pode levar muitos anos. Pessoalmente, eu não compreendi totalmente a verdadeira OOP até o ano passado. É uma pena que o Smalltalk não seja tão difundido nas faculdades como deveria ser. Isso realmente mostra o ponto que OOP é sobre objetos trocando mensagens, ao invés de classes serem variáveis ​​globais auto-contidas com funções.

Se você realmente é novo nas aulas, então o conceito pode demorar um pouco para ser entendido. Quando os encontrei pela primeira vez na 10ª série, não consegui até que alguém que soubesse o que eles estavam fazendo percorresse o código e explicasse o que estava acontecendo. Isso é o que eu sugiro que você tente.

0
adicionado

De certa forma, você pode considerar os "ponteiros" como um dos dois tipos mais fundamentais de software - o outro sendo "valores" (ou "dados") - que existem em um grande bloco de locais de memória endereçáveis ​​exclusivamente. Pense nisso. Objetos e estruturas, etc., não existem na memória, apenas valores e ponteiros. De fato, um ponteiro é um valor também .... o valor de um endereço de memória, que por sua vez contém outro valor .... e assim por diante.

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.

Quando você "desreferencia" o ponteiro intB, você está olhando para o endereço armazenado na memória do intB, localizando esse local e, em seguida, observando o valor armazenado lá (um 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
adicionado

Ponteiros e classes não são tópicos avançados em C ++. Eles são bem fundamentais.

Para mim, os ponteiros solidificaram quando comecei a desenhar caixas com setas. Desenhe uma caixa para um int. E int * agora é uma caixa separada com uma seta apontando para a caixa int.

Assim:

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

Com a caixa do meu ponteiro (barra) eu tenho a escolha de ver o endereço dentro da caixa. (Qual é o endereço de memória do foo). Ou eu posso manipular o que eu tenho um endereço para. Essa manipulação significa que eu estou seguindo essa seta para o inteiro (foo).

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

Classes são outro tópico inteiramente. Há alguns livros sobre design orientado a objetos, mas eu não sei os bons para iniciantes do topo da minha cabeça. Você pode ter sorte com um livro Java de introdução.

0
adicionado
Bem, eles são tópicos avançados para mim, haha, eu entendo seus exemplos aqui, mas quando eu tento entender o código de outra pessoa eu não consigo entender ... talvez eu só precise de mais experiência ... obrigado pela resposta.
adicionado o autor timmyg, fonte
Eu segundo isso. Para iniciantes, sempre SEMPRE traduza 'ponteiro' para 'endereço' e 'desreferência' para 'viagem para o endereço', da mesma forma que dirigir um carro. Os ponteiros para ponteiros tornam-se caixas de correio de encaminhamento - endereços que, quando você vai lá, encontra outro endereço em vez de um local de armazenamento.
adicionado o autor Aaron, fonte
Pode ser que muito desse código não esteja muito bem escrito. Certa vez, passei uma quantidade significativa de tempo tentando descobrir como funcionava um código pesado de ponteiro. Eu desisti e perguntei a um superior. Ele olhou para ele por 2 segundos e disse "Huh. Isso vai causar um acidente. Melhor consertá-lo." Experiência: A capacidade de olhar para um espécime, vê-lo fazer algo bizarro, e pensar "Há algo errado com isso" ao invés de "Há algo errado comigo".
adicionado o autor deworde, fonte

Noções básicas sobre ponteiros em C/C ++

Antes que alguém possa entender como os ponteiros funcionam, é necessário entender como as variáveis ​​são armazenadas e acessadas nos programas. Cada variável tem 2 partes - (1) o endereço de memória onde os dados são armazenados e (2) o valor dos dados armazenados.

O endereço de memória é geralmente chamado de lvalue de uma variável, e o valor dos dados armazenados é chamado de rvalue (l e r significa left e right).

Considere a afirmação:

int x = 10;

Internamente, o programa associa um endereço de memória à variável x. Neste caso, vamos supor que o programa atribua x para residir no endereço 1001 (não um endereço realístico, mas escolhido para simplificar). Portanto, o lvalue (endereço de memória) de x é 1001, e o rvalue (valor de dados) de x é 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.

Um ponteiro é simplesmente uma variável que pode ser usada para modificar outra variável. Isso é feito com um endereço de memória para o seu valor. Isto é, aponta para outro local na memória.

Criando um ponteiro para "x" é feito da seguinte forma:

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.

Supondo que xptr esteja atribuído a um endereço de memória de 1002, a memória do programa pode ter esta aparência:

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

A próxima peça do quebra-cabeça é o "operador indireto" ("*"), que é usado da seguinte maneira:

int y = *xptr;

O operador indireto diz ao programa para interpretar o rvalue de xptr como um endereço de memória em vez de um valor de dados. Ou seja, o programa procura o valor de dados (10) armazenado no endereço fornecido pelo xptr (1001).

Juntando tudo:

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

Agora que os conceitos foram explicados, aqui está um código para demonstrar o poder dos ponteiros:

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 a saída, você veria (Nota: o endereço da memória será diferente a 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
adicionado
obrigado pela resposta muito útil
adicionado o autor timmyg, fonte
Valores e valores não têm nada a ver com endereços de memória.
adicionado o autor Puppy, fonte

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, é um livro 'C', mas para os fundamentos do núcleo é difícil de bater

0
adicionado

Uma das coisas que realmente me ajudaram a entender esses conceitos é aprender UML - a Unified Modeling Language. Ver conceitos de design orientado a objetos em um formato gráfico realmente me ajudou a entender o que eles significam. Às vezes, tentar entender esses conceitos puramente observando o código-fonte que os implementa pode ser difícil de compreender.

Ver paradigmas orientados a objetos, como herança em forma gráfica, é uma maneira muito poderosa de entender o conceito.

A UML Distilled de Martin Fowler é uma introdução boa e breve.

0
adicionado

Não há substituto para praticar.

É fácil ler um livro ou ouvir uma palestra e sentir que você está seguindo o que está acontecendo.

O que eu recomendaria é pegar alguns dos exemplos de código (suponho que você os tenha em disco em algum lugar), compilá-los e executá-los, depois tentar alterá-los para fazer algo diferente.

  • Adicione outra subclasse a uma hierarquia
  • Adicione um método a uma classe existente
  • Alterar um algoritmo que repete encaminhar através de uma coleção para ir para trás em vez disso.

Eu não acho que exista algum livro "bala de prata" que vá fazer isso.

Para mim, o que levava para casa o que os ponteiros significavam era trabalhar em assembly e ver que um ponteiro era na verdade apenas um endereço, e que ter um ponteiro não significava que o que ele apontava era um objeto significativo.

0
adicionado

Para ponteiros e classes, aqui está minha analogia. Eu vou usar um baralho de cartas. O baralho de cartas tem um valor nominal e um tipo (9 de copas, 4 de espadas, etc.). Então, em nossa linguagem de programação semelhante ao C ++ do "Deck of Cards", diremos o seguinte:

HeartCard card = 4;//4 of hearts!

Agora, você sabe onde está o 4 de copas porque, por golly, você está segurando o baralho, com a face para cima na sua mão, e está no topo! Então, em relação ao resto das cartas, vamos apenas dizer que o 4 de copas está no BEGINNING. Então, se eu lhe perguntasse em que cartão está no BEGINNING, você diria: "O 4 de copas, é claro!". Bem, você apenas "apontou" para onde o cartão está. Na nossa linguagem de programação "Deck of Cards", você poderia também dizer o seguinte:

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

Agora, vire o seu baralho de cartas. O lado de trás é agora BEGINNING e você não sabe o que é o cartão. Mas, digamos que você pode fazer o que quiser, porque você é cheio de magia. Vamos fazer isso no nosso "Deck of Cards" langauge!

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

Bem, MakeMyCard ("10 de copas") você estava fazendo a sua mágica e sabendo que queria apontar para o BEGINNING, fazendo o cartão de 10 corações! Você vira seu cartão e voila! Agora, o * pode jogá-lo fora. Em caso afirmativo, verifique isso:

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!

Quanto às aulas, estamos usando classes no exemplo definindo um tipo como HeartCard. Nós sabemos o que é um HeartCard ... É um cartão com um valor e o tipo de coração! Então, classificamos isso como um HeartCard. Cada idioma tem uma maneira similar de definir ou "classificar" o que você quer, mas todos compartilham o mesmo conceito! Espero que isso tenha ajudado ...

0
adicionado
Essa foi uma analogia bastante ruim.
adicionado o autor FlySwat, fonte

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;

você está declarando uma variável que pode conter um local de memória de um int. É simples assim. Além disso, não tenha medo de aritmética de ponteiro, apenas sempre tem em mente um "mapa de memória" quando você está lidando com ponteiros e pensa em termos de percorrer endereços de memória.

Classes em C ++ são apenas uma maneira de definir tipos de dados abstratos. Eu sugiro ler um bom livro OOP para entender o conceito, então, se você estiver interessado, aprenda como os compiladores de C ++ geram código para simular OOP. Mas este conhecimento virá a tempo, se você ficar com o C ++ tempo suficiente :)

0
adicionado

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
adicionado

No caso das classes, eu tive três técnicas que realmente me ajudaram a fazer o salto para a programação orientada a objetos reais.

O primeiro foi que trabalhei em um projeto de jogo que fazia uso pesado de classes e objetos, com uso pesado de generalização (espécie de ou é-um relacionamento, ex-aluno é um tipo de pessoa) e composição (tem um relacionamento, ex. estudante tem um empréstimo estudantil). Desmembrar esse código exigiu muito trabalho, mas realmente trouxe as coisas em 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 fim, ajudo a orientar os alunos da minha faculdade em programação. Tudo o que posso dizer sobre isso é que você aprende muito ensinando e vendo a abordagem de outras pessoas a um problema. Muitas vezes um aluno experimenta coisas que eu nunca teria pensado, mas geralmente fazem muito sentido e só têm problemas para implementar a ideia.

Minha melhor palavra de conselho é que é preciso muita prática, e quanto mais você programar, melhor você entenderá.

0
adicionado