Я хотел бы получить представление о том, для чего каждый предназначен.
Очевидно, что вы можете размыть различия в соответствии с вашим стилем программирования, но в целом структура представляет собой структурированную часть данных. Объект - это суверенная сущность, которая может выполнять какую-то задачу. В большинстве систем объекты имеют некоторое состояние и, как результат, имеют за собой некоторые структурированные данные. Однако одной из основных функций хорошо продуманного класса является скрытие данных - именно то, как класс достигает того, что он делает, непрозрачен и не имеет значения.
Поскольку классы могут использоваться для представления классических структур данных, таких как массивы, хэш-карты, деревья и т.д., вы часто видите их как отдельные вещи в блоке структурированных данных.
Массив - это блок неструктурированных данных. Во многих языках программирования каждая отдельная вещь в массиве должна иметь один и тот же базовый тип (такой как каждый из которых является целым числом, каждый из которых является строкой или аналогичным), но это не так на многих других языках.
Как рекомендации:
Неявная цель объекта заключается в том, чтобы напрямую связывать задачи с данными, на которых они могут работать, и объединять их все вместе, чтобы никакая другая часть системы не вмешивалась. Соблюдение надлежащих объектно-ориентированных принципов проектирования может потребовать сначала дисциплины, но в конечном итоге значительно улучшит структуру вашего кода и, следовательно, вашу способность решать большие проекты и работать с другими.
Вообще говоря, объекты приносят полную объектно-ориентированную функциональность (методы, данные, виртуальные функции, наследование и т.д. и т.д.), тогда как структуры - это просто организованная память. Структуры могут поддерживать или не поддерживать методы/функции, но обычно они не поддерживают наследование и другие полные функции ООП.
Обратите внимание, что я сказал, вообще говоря,... отдельные языки могут перегружать терминологию, но они хотят.
Массивы не имеют ничего общего с OO. Действительно, почти каждый язык поддерживает массивы поддержки. Массивы - это только блоки памяти, обычно содержащие ряд похожих элементов, обычно индексируемых как-то.
В ООП нет понятия "struct". Определение структур зависит от используемого языка. Например, в С++ классы и структуры одинаковы, но члены класса являются закрытыми по умолчанию, а члены структуры являются общедоступными, чтобы поддерживать совместимость с C-структурами. В С#, с другой стороны, struct используется для создания типов значений, а класс - для ссылочных типов. C имеет структуры и не является объектно-ориентированным.
Опять же, это зависит от используемого языка. Обычно структуры представляют собой POD (обычные старые данные), что означает, что они не определяют поведение, действующее на данные, и в основном используются для представления записей, а не объектов. Это просто соглашение и не применяется в С++.
Массив очень отличается. Массив обычно представляет собой однородный набор элементов, индексированных целым числом. Структура представляет собой гетерогенную коллекцию, в которой элементы получают доступ по имени. Вы должны использовать массив для представления коллекции объектов того же типа (например, массива цветов), в то время как вы должны использовать структуру для представления записи, содержащей данные для определенного объекта (один цвет с красным, зеленым, и синие элементы)
Краткий ответ: Структуры - это типы значений. Классы (объекты) являются ссылочными типами.
По своей природе объект имеет методы, а структура не имеет.
(ничто не мешает вам иметь объект без методов, jus, поскольку ничто не останавливает вас, скажем, сохраняя целое число в переменной с плавающей запятой)
Массивы упорядочивают набор элементов, которые (как правило) имеют одинаковые типы. Доступ к элементам можно получить по индексу. Классические массивы допускают только целые индексы, однако современные языки часто предоставляют так называемые ассоциативные массивы (словари, хэши и т.д.), Которые позволяют использовать, например, строки как индексы.
Структура представляет собой набор именованных значений (полей), которые могут быть "разных типов" (например, поле a хранит целочисленные значения, поле b - строковые значения и т.д.). Они (а) группируют логически связанные значения и (б) упрощают изменение кода, скрывая детали (например, изменение структуры структуры не влияет на подпись функции, работающей с этой структурой). Последний называется "инкапсуляция".
Террористически объект - это экземпляр структуры, демонстрирующий некоторое поведение в ответ на отправляемые сообщения (т.е. на большинстве языков, имеющих некоторые методы). Таким образом, очень полезная цель объекта заключается в этом поведении, а не в его полях.
Различные объекты могут демонстрировать различное поведение в ответ на одни и те же сообщения (те же самые методы, которые вызывают), который называется "полиморфизм".
Во многих (но не во всех) языках объекты принадлежат некоторым классам, а классы могут формировать иерархии (называемые "наследованием" ).
Так как методы объектов могут работать с полями напрямую, поля могут быть скрыты от доступа любым кодом, кроме этих методов (например, помечая их как private). Таким образом, уровень инкапсуляции для объектов может быть выше, чем для структур.
Обратите внимание, что разные языки добавляют к этим терминам другую семантику.
например:.
на языках CLR (С#, VB.NET и т.д.) struct выделяются в стеках/в регистрах, а объекты создаются в куче.
в С++ struct по умолчанию все поля public, а объекты (экземпляры классов) имеют все поля private.
в некоторых динамических языках объекты - это просто ассоциативные массивы, в которых хранятся значения и методы.
Конечно, вы можете использовать константы или что-то другое вместо переменных, я просто пытаюсь показать основные принципы.
Этот ответ может потребоваться вниманию более опытного программиста, но одно из различий между структурами и объектами заключается в том, что структуры не имеют возможности для отражения, тогда как объекты могут. Отражение - это способность объекта сообщать о свойствах и методах, которые он имеет. Таким образом, "объект-проводник" может находить и перечислять новые методы и свойства, созданные в пользовательских классах. Другими словами, отражение может быть использовано для разработки интерфейса объекта. Со структурой я не знаю, как я могу перебирать элементы структуры, чтобы узнать, что они называются, какой тип они и каковы их значения.
Если вы используете structs как замену для объектов, то можно использовать функции, чтобы обеспечить эквивалент методов. По крайней мере, в моем коде структуры часто используются для возврата данных из пользовательских функций в модули, которые содержат бизнес-логику. Структуры и функции столь же просты в использовании, как и объекты, но функции не поддерживают XML-комментарии. Это означает, что мне постоянно приходится смотреть на блок комментариев в верхней части функции, чтобы увидеть, что делает функция. Часто мне приходится читать исходный код функции, чтобы увидеть, как обрабатываются граничные случаи. Когда функции вызывают другие функции, мне часто приходится преследовать что-то несколько уровней, и становится трудно понять, что происходит. Это приводит к другому преимуществу ООП против структур и функций. В OOP есть комментарии XML, которые отображаются в виде подсказок в среде IDE (в большинстве, но не во всех языках ООП), а в ООП есть также определенные интерфейсы и часто диаграмма объектов (если вы решили их создать). Мне становится ясно, что определяющим преимуществом ООП является возможность документировать, какой код выполняет то, что и как он относится к другому коду - интерфейсу.
Когда и почему мы используем объект в отличие от структуры?
Это ключевой вопрос. Я использую модули структуры и процедурного кода, чтобы обеспечить большую часть преимуществ ООП. Структуры обеспечивают большую часть возможностей хранения данных для объектов (кроме свойств только для чтения). Процедурные модули обеспечивают завершение кода, аналогичное завершению объектов. Я могу ввести module.function в IDE вместо object.method. Полученный код выглядит одинаково. Большинство моих функций теперь возвращают stucts, а не одиночные значения. Эффект на мой код был драматичным, с повышением читаемости кода и сокращением числа строк. Я не знаю, почему процедурное программирование, которое широко использует структуры, не является более распространенным явлением. Почему бы просто не использовать ООП? Некоторые из языков, которые я использую, являются процедурами (PureBasic), а использование структур позволяет использовать некоторые преимущества ООП. Другие языки позволяют выбирать процедурные или ООП (VBA и Python). В настоящее время мне легче использовать процедурное программирование, и в моей дисциплине (экология) мне очень сложно определить объекты. Когда я не могу понять, как группировать данные и функции вместе в объекты в философски связной коллекции, тогда у меня нет основы для создания классов/объектов. С помощью структур и функций нет необходимости определять иерархию классов. Я могу свободно перемешать функции между модулями, что помогает мне улучшить организацию моего кода, когда я иду. Возможно, это является предшественником перехода OO.
Код, написанный с помощью структур, имеет более высокую производительность, чем код на основе ООП. OOP-код имеет инкапсуляцию, наследование и полиморфизм, однако я считаю, что процедурный код на основе структуры/функции часто разделяет эти характеристики. Функция возвращает значение только своему вызывающему абоненту и только в пределах области действия, тем самым обеспечивая инкапсуляцию. Аналогично, функция может быть полиморфной. Например, я могу написать функцию, которая вычисляет разницу во времени между двумя местами с двумя внутренними алгоритмами, которая учитывает международную линию дат, а другая - нет. Наследование обычно относится к методам, наследующим от базового класса. Существует наследование видов с функциями, которые вызывают другие функции и используют структуры для передачи данных. Простым примером является передача сообщения об ошибке через стек вложенных функций. Когда сообщение об ошибке передается, оно может быть добавлено вызывающими функциями. Результатом является трассировка стека с очень описательным сообщением об ошибке. В этом случае сообщение унаследовано через несколько уровней. Я не знаю, как описать это нижнее наследование (программирование, управляемое событиями?), Но это функция использования функций, которые возвращают структуры, отсутствующие в процедурном программировании, с использованием простых возвращаемых значений. На данный момент я не сталкивался с ситуациями, когда ООП был бы более продуктивным, чем функции и структуры. Удивительная вещь для меня заключается в том, что очень мало кода, доступного в Интернете, написано именно так. Это заставляет меня задаться вопросом, есть ли причина для этого?
Я также считаю, что стоит упомянуть, что понятие структуры очень похоже на "объект" в Javascript, который определен очень иначе, чем объекты на других языках. Оба они упоминаются как "foo.bar", и данные структурированы аналогично.