В C++ я не могу схватить указатели и классы

Понимание указателей в C/C++

Прежде чем можно понять, как указатели работают, необходимо понять, как переменные сохранены и получены доступ в программах. Каждая переменная имеет 2 части к нему - (1) адрес памяти, где данные хранятся и (2) значение данных сохранено.

Адрес памяти часто упоминается как lvalue переменной, и значение хранивших данных упоминается как rvalue (l и значение r левого и правого).

Рассмотрите оператор:

int x = 10;

Внутренне, программа связывает адрес памяти с переменной x. В этом случае давайте предположим, что программа присваивает x для нахождения в адресе 1001 (не реалистический адрес, но выбранный для простоты). Поэтому lvalue (адрес памяти) x 1001, и rvalue (значение данных) x равняется 10.

К rvalue получают доступ путем простого использования переменной “x”. Для доступа к lvalue “адрес” оператора (‘& ’) необходим. Выражение ‘&x’ читается как "адрес x".

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

Значение, сохраненное в x, может быть изменено в любое время (например, x = 20), но адрес x (&x) никогда не может изменяться.

Указатель является просто переменной, которая может использоваться для изменения другой переменной. Это делает это при наличии адреса памяти для его rvalue. Таким образом, это указывает на другое местоположение в памяти.

Создание указателя на “x” сделано следующим образом:

int* xptr = &x;

“Интервал*” говорит компилятору, что мы создаем указатель на целочисленное значение. “= &x” часть говорит компилятору, что мы присваиваем адрес x к rvalue xptr. Таким образом мы говорим компилятору, что xptr “указывает на” x.

Предположение, что xptr присвоен адресу памяти 1 002, затем память программы, могло бы быть похожим на это:

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

Следующая часть загадки является "косвенным оператором" (‘* ’), который используется следующим образом:

int y = *xptr;

Косвенный оператор говорит программе интерпретировать rvalue xptr как адрес памяти, а не значение данных. Таким образом, программа ищет значение данных (10), сохраненное в адресе, обеспеченном xptr (1001).

Соединение всего этого:

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

Теперь, когда понятия были объяснены, вот некоторый код для демонстрации питания указателей:

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);

Для вывода Вы видели бы (Примечание: адрес памяти будет отличаться каждый раз):

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

Заметьте, как присвоение значения к ‘*xptr’ изменило значение ‘x’. Это вызвано тем, что ‘*xptr’ и ‘x’ относятся к тому же местоположению в памяти, как свидетельствуется ‘&x’ и ‘xptr’ наличие того же значения.

Ваша проблема, кажется, ядро C в C++, не самом C++. Вовлеките себя Kernighan & Ritchie (Язык программирования C). Вдохните его. Это - очень хороший материал, одна из лучших книг языка программирования, когда-либо записанных.

Указатели не являются своего рода волшебным материалом, Вы используете их все время!
Когда Вы говорите:

интервал a;

и компилятор генерирует устройство хранения данных для, Вы практически говорите, что объявляете
интервал и Вы хотите назвать свою ячейку памяти 'a'.

Когда Вы говорите:

интервал *a;

Вы объявляете переменную, которая может содержать ячейку памяти интервала. Это - это простое. Кроме того, не бойтесь об адресной арифметике с указателями, просто всегда имейте в виду "карту распределения памяти", когда Вы будете иметь дело с указателями и будете думать с точки зрения обхода через адреса памяти.

Классы в C++ являются всего одним способом определить абстрактные типы данных. Я предложил бы читать хорошую книгу ООП для понимания понятия, затем, если Вы интересно, изучаете, как компиляторы C++ генерируют код для моделирования ООП. Но это знание прибудет вовремя, если Вы будете придерживаться C++ достаточно долго :)

Можно найти эту статью Joel поучительной. Как в стороне, если Вы "работали в C++ в течение некоторого времени" и получили высшее образование в CS, Вы, возможно, перешли к JavaSchool (я утверждал бы, что Вы не работали в C++ вообще; Вы работали в C, но использовали компилятор C++).

Кроме того, только к второму ответы hojou и nsanders, указатели очень фундаментальны для C++. Если Вы не понимаете указатели, то Вы не понимаете основы C++ (подтверждающий, что этот факт является началом понимания C++, между прочим). Точно так же, если Вы не понимаете классы, затем Вы не понимаете основы C++ (или OO в этом отношении).

Для указателей я думаю, таща с полями, прекрасная идея, но работающий в блоке также хорошая идея. Любые инструкции, что относительная адресация использования получит Вас к пониманию того, что указатели скорее быстро, я думаю.

Что касается классов (и объектно-ориентированное программирование в более общем плане), я рекомендовал бы Stroustrups "последний выпуск" Языка Программирования на C++. Мало того, что это - канонический ссылочный материал C++, но и это также имеет довольно мало материала по большому количеству других вещей от основных объектно-ориентированных иерархий классов и наследования полностью до принципов разработки в больших системах. Это - очень хорошее чтение (если не немного гущи и краткий в местах).

Вы читали Bjarne Stroustrup Язык Программирования на C++? Он создал C++.

Облегченный FAQ C++ также хорош.

Точка, в которой я действительно получил указатели, кодировала TurboPascal на FatMac (приблизительно приблизительно 1984) - который был собственным языком Mac в то время.

Mac имел нечетную модель памяти, посредством чего при выделении адрес память была сохранена в указателе на "куче", но местоположение которого само не гарантировалось и вместо этого стандартные программы обработки памяти возвратили указатель на указатель - называемый дескриптором. Следовательно, для доступа к любой части выделенной памяти было необходимо разыменовать дескриптор дважды. Это требовало времени, но постоянная практика в конечном счете управляла уроком домой.

Обработку указателя Паскаля легче схватить, чем C++, где синтаксис не помогает новичку. Если Вы действительно и действительно застреваете, понимая указатели в C затем, Ваш наилучший вариант мог бы состоять в том, чтобы получить копию компилятор Паскаля и попытаться писать некоторый основной код указателя в нем (Паскаль около достаточно к C, Вы получите основы через несколько часов). Связанные списки и т.п. были бы хорошим выбором. После того как Вы довольны теми, возвращаются к C++, и с понятиями освоил, Вы найдете, что утес не будет выглядеть настолько крутым.

Классы относительно легко схватить; ООП может взять Вас много лет. Лично, я не полностью схватил истинное ООП до последнего выхода года. Это слишком плохо, что Smalltalk не так широко распространен в колледжах, как это должно быть. Это действительно убедительно доказывает точку зрения, что ООП об объектах, торгуя сообщениями вместо классов, являющихся автономными глобальными переменными с функциями.

Если Вы действительно плохо знакомы с классами, то понятие может требовать времени к схватыванию. Когда я сначала встретился с ними в 10-м классе, я не получил его, пока у меня не было кого-то, кто знал то, что они делали шаг через код и объясняют, что продолжалось. Именно это я предлагаю, чтобы Вы попробовали.

Для лучше понимания указателей я думаю, может быть полезно посмотреть на то, как ассемблер работает с указателями. Понятие указателей является действительно одной из фундаментальных частей ассемблера и x86 архитектуры инструкции по процессору. Возможно, это отчасти позволит, Вы упали как указатели, естественная часть программы.

Относительно классов, кроме парадигмы OO я думаю, что может быть интересно посмотреть на классы с двоичной точки зрения низкого уровня. Они не то, что комплекс в этом отношении на базовом уровне.

Можно читать В Модели Объекта C++, если Вы хотите получить лучшее понимание того, что является нижней моделью объекта C++.

Притворитесь, что указатель является адресом массива.

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

это - графическое упрощение, но по большей части, пока Вы никогда не хотите знать то, что то число - или установило его вручную, необходимо быть в порядке.

Назад, когда я понял C, у меня были некоторые макросы, которые я имел, который более или менее разрешил Вам использовать указатели точно так же, как они были индексом массива в памяти. Но я давно потерял тот код и давно забыл.

Я вспоминаю, что это запустилось с

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

и это самостоятельно едва полезно. Надо надеяться, кто-то еще может подробно остановиться на той логике.

Одна из вещей, которые действительно помогли мне понять эти понятия, состоит в том, чтобы изучить UML - Унифицированный язык моделирования. Наблюдение понятия объектно-ориентированного дизайна в графическом формате действительно помогло мне изучить то, что они имеют в виду. Иногда попытку понять эти понятия просто путем взгляда на то, какой исходный код реализует их, может быть трудно постигать.

Наблюдение объектно-ориентированных парадигм как наследование в графической форме является очень мощным способом схватить понятие.

Дистиллированный UML Martin Fowler является хорошим, кратким введением.

Для классов:

breakthru момент для меня был, когда я узнал об интерфейсах. Идея абстрагировать далеко детали того, как Вы записали, решила проблему и предоставление просто, список методов, которые взаимодействуют с классом, был очень проницателен.

На самом деле мой преподаватель явно сказал нам, что будет градуировать наши программы путем включения наших классов в его тестовую обвязку. Классификация была бы сделана на основе требований, которые он дал нам и ли разрушенная программа.

Короче говоря, классы позволяют Вам обернуть функциональность и назвать ее более чистым способом (большую часть времени, всегда существуют исключения),

Лучшая книга, которую я прочитал по этим темам, Думает в C++ Bruce Eckel. Можно загрузить его бесплатно здесь.

В некотором смысле можно полагать, что "указатели" один из этих двух наиболее фундаментальных типов в программном обеспечении - другого являющегося "значениями" (или "данные") - которые существуют в огромном блоке исключительно адресуемых ячеек памяти.Подумайте об этом. Объекты и структуры и т.д. действительно не существуют в памяти, только значения и указатели делают. На самом деле указатель является значением также.... значение адреса памяти, который в свою очередь содержит другое значение.... и так далее.

Так, в C/C++, когда Вы объявляете "интервал" (Инта), Вы определяете блок на 32 бита памяти, которая содержит значение - число. Если Вы затем объявляете "международный указатель" (intB), Вы определяете блок на 32 бита памяти, которая содержит адрес интервала. Я могу присвоить последнего для указания первому путем утверждения "intB = &intA", и теперь 32 бита памяти, определенной как intB, содержат адрес, соответствующий району Инты в памяти.

Когда Вы "разыменовываете" intB указатель, Вы смотрите на адрес, сохраненный в памяти intB, находя что местоположение и затем рассмотрение значения сохраненный там (число).

Обычно я встретился с беспорядком, когда люди теряют след точно, что это, они имеют дело с тем, поскольку они используют "и", "*" и "->" операторы - действительно ли это - адрес, значение или что? Просто необходимо быть сосредоточены на том, что адреса памяти являются просто местоположениями, и что значения являются двоичной информацией, хранившей там.

В случае классов у меня было три метода, которые действительно помогли мне превратить переход в реальное объектно-ориентированное программирование.

Первое было, я работал над игровым проектом, который сделал интенсивное использование классов и объектов с интенсивным использованием обобщения (отчасти, или - отношения, напр. студент является своего рода человеком), и состав (имеет - отношения, напр. у студента есть кредит на образование). Разбивание этого кода взяло большую работу, но действительно принесло вещи в перспективу.

Вторая вещь, которая помогла, была в моем Системном Аналитическом классе, где я должен был сделать http://www.agilemodeling.com/artifacts/classDiagram.htm"> диаграммы классов UML. Они, которые я просто действительно нашел, помогли мне понять структуру классов в программе.

Наконец, я помогаю студентам обучающей программы в своем колледже в программировании. Все, что я могу действительно сказать об этом, является Вами, изучают много путем обучения и путем наблюдения подхода других людей к проблеме. Много раз студент будет пробовать вещи, о которых я никогда не думал бы, но обычно имею большой смысл, и у них просто есть проблемы при реализовывании их идеи.

Мой лучший небольшой совет - это, берет много практики, и чем больше Вы программируете, тем лучше Вы поймете это.

Изучите ассемблер и затем изучите C. Затем Вы будете знать то, что базовые принципы машины (и thefore указатели).

Указатели и классы являются фундаментальными аспектами C++. Если Вы не понимаете их затем, это означает, что Вы действительно не понимаете C++.

Лично я сдержался на C++ в течение нескольких лет, пока я не чувствовал, что у меня было твердое схватывание C и что происходило под капотом в ассемблере. Хотя это было довольно долгое время назад теперь, я думаю, что это действительно принесло пользу моей карьере, чтобы понять, как компьютер работает на низком уровне.

Обучение программировать может занять много лет, но необходимо придерживаться его, потому что это - очень полезная карьера.

Нет никакого substiture для осуществления.

Легко прочитать книгу или слушать лекцию и чувствовать, что Вы следуете за тем, что продолжается.

То, что я рекомендовал бы, берет некоторые примеры кода (я предполагаю, что у Вас есть они на диске где-нибудь), скомпилируйте их и выполните их, затем попытайтесь изменить их, чтобы сделать что-то другое.

• Добавьте другой подкласс к иерархии
• Добавьте метод к существующему классу
• Измените алгоритм, который выполняет итерации вперед через набор для движения назад вместо этого.

Я не думаю, что существует любая книга "серебряной пули", это собирается сделать это.

Для меня, что донесло, какие предназначенные указатели работали в блоке и видели, что указатель был на самом деле просто адресом, и что наличие указателя не означало, что то, на что это указало, было значимым объектом.

Для указателей:

Я нашел, что это сообщение имело очень вдумчивую дискуссию об указателях. Возможно, это помогло бы. Вы - familar со ссылками такой как в C#? Это - что-то, что на самом деле относится к чему-то еще? Это - вероятно, хорошее начало для понимания указателей.

Кроме того, посмотрите на сообщение Kent Fredric ниже на другом способе представиться к указателям.

Книга, которая взломала указатели для меня, Иллюстрировала Ansi C Donald Alcock. Ее полные из hand-drawn-style блочных и стрелочных диаграмм, которые иллюстрируют указатели, адресную арифметику с указателями, массивы, строковые функции и т.д...

Очевидно, это - книга 'C', но для базовых основных принципов его твердое для избиения

От ответа lassevek до подобного вопроса на ТАК:

Указатели являются понятием, которое для многих может сбивать с толку сначала, в особенности когда дело доходит до копирования значений указателя вокруг и все еще ссылки на тот же блок памяти.

Я нашел, что лучшая аналогия должна рассмотреть указатель как листок бумаги с адресом дома на нем и блоком памяти, на который это ссылается как фактический дом. Все виды операций могут таким образом быть легко объяснены:

• Значение указателя копии, просто запишите адрес на новом листке бумаги
• Связанные списки, листок бумаги в доме с адресом следующего дома на нем
• При освобождении памяти уничтожьте дом и сотрите адрес
• Утечка памяти, Вы теряете листок бумаги и не можете найти дом
• При освобождении памяти, но сохранении (теперь недопустимыми) ссылка, уничтожьте дом, сотрите один из листков бумаги, но имейте другой листок бумаги со старым адресом на нем, когда Вы перейдете к адресу, Вы не найдете дом, но Вы могли бы найти что-то, что напоминает руины одного
• Переполнение буфера, Вы перемещаете больше материала в дом, чем можно возможно соответствовать, устремляясь в соседний дом

Для понимания указателей я не могу рекомендовать книгу K&R достаточно высоко.

Указатели уже, кажется, обращены (никакая предназначенная игра слов) в других ответах.

Классы фундаментальны для OO. Я испытал огромные затруднения при завертывании моей головы в OO - как, десять лет неудачных попыток. Книга, которая наконец помогла мне, была "Применением Craig Larman UML и Шаблонов". Я знаю кажется будто, что это о чем-то другом, но это действительно делает отличную работу по упрощению Вас в мир классов и объектов.

Мы просто обсуждали некоторые аспекты C++ и OO за ланчем, кто-то (великий инженер на самом деле) говорил, что, если у Вас нет действительно сильного фона программирования перед изучением C++ он буквально разрушит Вас.

Я настоятельно рекомендую изучение другого языка сначала, затем смещаясь к C++, когда Вам нужен он. Это не похоже существует что-либо большое об указателях, они - просто остаточная часть, перенесенная от того, когда это было трудно для компилятора, преобразовывают операции в блок эффективно без них.

В эти дни, если компилятор не может оптимизировать операцию над массивом лучше затем, Вы можете с помощью указателей, компилятор повреждается.

Не понимайте меня превратно, я не говорю, что C++ ужасен или что-либо, и не хотят запускать обсуждение поддержки, я использовал его и использую его иногда теперь, я просто рекомендую запустить с чего-то еще.

Это - действительно НЕ как обучение вождению ручного автомобиля затем легко способность применить это к автоматическому, это больше похоже на обучение вождению на одном из тех огромных подъемных кранов конструкции, затем предполагающих, что это будет применяться, когда Вы начнете водить автомобиль - затем Вы ведете свой автомобиль вниз середина улицы на уровне 5 миль в час с Вашими аварийными лампами на.

[редактирование] рассматривая тот последний абзац - я думаю, что это, возможно, было моей самой точной аналогией когда-либо!

Указатели и классы являются совершенно другими темами, таким образом, я действительно не смешал бы их во вместе как это. Из этих двух я сказал бы, что указатели более фундаментальны.

Хорошее осуществление для приобретения знаний о том, что указатели, следующее:

1. создайте связанный список
2. выполните итерации через него от начала до конца
3. инвертируйте его так, чтобы голова была теперь спиной, и спина является теперь головой

Сделайте все это на электронной доске сначала. Если можно сделать это легко, у Вас больше не должно быть проблем при понимании, каковы указатели.

Я раньше имел проблему, понимают указатели в Паскале путь назад :) После того как я начал делать, ассемблерные указатели был действительно единственный способ получить доступ к памяти, и это просто поразило меня. Это могло бы походить на далекий выстрел, но испытание ассемблера (который всегда является хорошей идеей попытаться понять то, о чем компьютеры действительно), вероятно, будет преподавать Вам указатели. Классы - хорошо я не понимаю, что Вашей проблемой - было Ваше обучение чистое структурное программирование? Класс является просто логическим способом посмотреть на реальные модели - Вы пытаетесь решить проблему, которой можно было подвести итог во многих объектах/классах.

Указатели и классы не являются действительно усовершенствованными темами в C++. Они довольно фундаментальны.

Для меня укрепились указатели, когда я начал тянуть поля со стрелками. Потяните поле для интервала. И интервал* является теперь отдельным полем со стрелкой, указывающей на международное поле.

Так:

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

С полем моего указателя (панель) у меня есть выбор любого рассмотрения адреса в поле. (Который является адресом памяти нечто). Или я могу управлять тем, к чему у меня есть адрес. То управление означает, что я следую за той стрелкой к целому числу (нечто).

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

Классы являются другой темой полностью. Существуют некоторые книги по объектно-ориентированному проектированию, но я не знаю хорошие для новичков вершины моей головы. У Вас могла бы быть удача с вводной книгой Java.

Эта ссылка имеет видео, описывающее, как указатели работают с claymation. Информативный, и легкий к обзору.

Эта страница имеет некоторую хорошую информацию об основных из классов.

Для указателей и классов, вот моя аналогия. Я буду использовать деку карт. Дека карт имеет номинальную стоимость и тип (9 из основ, 4 из лопат, и т.д.). Таким образом в нашем C++ как язык программирования "Деки Карт" мы скажем следующее:

HeartCard card = 4; // 4 of hearts!

Теперь, Вы знаете, где 4 из основ - то, потому что ей-богу, Вы держите деку, сталкиваетесь в Вашей руке, и это наверху! Таким образом относительно остальной части карт, мы просто скажем, что 4 из основ ВНАЧАЛЕ. Так, если бы я спросил Вас, что карта ВНАЧАЛЕ, то Вы сказали бы, "4 из основ, конечно!". Ну, Вы просто "указали" на меня туда, где карта. В нашей "Деке Карт" язык программирования, Вы могли точно также сказать следующее:

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

Теперь, переверните свою деку карт. Задняя сторона теперь НАЧИНАЕТСЯ, и Вы не знаете, какова карта. Но, скажем, можно сделать его вообще, Вы хотите, потому что Вы полны волшебства. Давайте сделаем это в нашей "Деке Карт" язык!

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

Ну, MakeMyCard ("10 из основ") был Вами делающий Ваше волшебство и зная, что Вы хотели указать на НАЧАЛО, делая карту 10 из основ! Вы переворачиваете свою карту и, вуаля! Теперь, * может отбросить Вас. Если так, проверьте это:

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!

Что касается классов, мы использовали классы в примере путем определения типа как HeartCard. Мы знаем, каков HeartCard... Это - карта со значением и типом основы! Так, мы классифицировали это как HeartCard. Каждый язык имеет похожий способ определить или "классифицировать" то, что Вы хотите, но они все совместно используют то же понятие! Надеюсь, что это помогло...