Перед ООП, являются членами структуры данных левой общественности?

ООП не изобрели инкапсуляции и не является синонимом заключения. Многие языки ООП не имеет c++/стиль Java модификаторы доступа. Многие не-ООП языках есть различные способы предложить инкапсуляции.

Один классический подход для заключения закрытие, как в функциональное программирование. Это значительно старше, чем ООП, но в определенном смысле эквивалентны. Е. Г. в JavaScript мы можем создать объект, похожий на этот:

в

function Adder(x) {
  this.add = function add(y) {
    return x + y;
  }
}

var plus2 = new Adder(2);
plus2.add(7);  //=> 9

Объект выше плюс 2 нет элементов, которые позволили бы прямой доступ к Х – это'ы полностью инкапсулируются. Добавить () метод является закрытие над переменной x.

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

в

#ifndef ADDER_H
#define ADDER_H

typedef struct AdderImpl *Adder;

Adder Adder_new(int x);
void Adder_free(Adder self);
int Adder_add(Adder self, int y);

#endif

Теперь мы можем написать код, который использует этот интерфейс гадюка, не имея доступа к его поля, например:

в

Adder plus2 = Adder_new(2);
if (!plus2) abort();
printf("%d\n", Adder_add(plus2, 7));  /* => 9 */
Adder_free(plus2);

И здесь будет полностью инкапсулированы детали реализации:

в

#include "adder.h"

struct AdderImpl { int x; };

Adder Adder_new(int x) {
  Adder self = malloc(sizeof *self);
  if (!self) return NULL;
  self->x = x;
  return self;
}

void Adder_free(Adder self) {
  free(self);
}

int Adder_add(Adder self, int y) {
  return self->x + y;
}

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

Там's также наблюдение, что классы в ООП-языках, таких как C++ или Java не используются для objects (в смысле сущностей, которые разрешают операции с помощью позднего связывания/динамическая диспетчеризация), а лишь для abstract сведения types (где мы определяем открытый интерфейс, который скрывает внутренние детали реализации). В статье On понимание абстракции данных, Revisited (Кука, 2009г) обсуждает эту разницу более подробно.

Но да, многие языки не имеют никакой механизм инкапсуляции. На этих языках, члены структуры являются публичной. В крайнем случае, было бы именования дестимулирование использования. Е. Г. Я думаю, что Паскаль не имел полезный механизм инкапсуляции.

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

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

фу.ч:

struct queue;
struct queue* makeQueue();
void add2Queue(struct queue* q, int value);
...

фу.с:

struct queue {
    int* head;
    int* head;
};
struct queue* makeQueue() { .... }
void add2Queue(struct queue* q, int value) { ... }

Посмотрите на пакет SDK для Windows! Он использует ручки и UINT_PTR, и тому подобное, чтобы быть универсальными ручками в памяти используемые в API, эффективно делая реализаций частная.

"и непрозрачные типы данных", было хорошо известное понятие, когда я сделал свою степень по информатике 30 лет назад. Мы не рассматривали ООП как он не был в общем пользовании в то время и "Программирование" и считается более правильным.

Модула-2 была непосредственная поддержка для них, см. https://www.modula2.org/reference/modules.php.

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

Также был использован нередко конвенции. Например, любой области начиная с “_” не должны быть доступны вне файла, который владел данных. Это было легко обеспечивается создание пользовательских инструментов проверки.

Каждый масштабный проект, над которыми я работал, (до того как я перешел на C++, затем c#) было в месте, чтобы предотвратить и"частные" и передачу данных на неправильный код. Это было просто немного менее стандартизированы, чем сейчас.

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

Есть несколько методов, чтобы сделать это тяжелее, чтобы открыть и"частные" и переменные, наиболее распространенными из которых являются идиому Pimpl. Это ставит ваш собственный переменные в отдельную структуру, с просто указатель, выделенных в публичных заголовочных файлах. Это означает дополнительную разыменовать и получить любые частные переменные, что-то вроде `((private_impl)(объект->частная))->actual_value, который получает раздражает, поэтому на практике используется редко.

Структуры данных не'т иметь, что "членов" и, только поля данных (если это типа). Видимость была, как правило, устанавливается на весь тип. Однако, это не может рассматриваться как ограничение, как вы думаете, потому что функций там'т часть записи.

Позвольте'ы и немного истории здесь...

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

Еще один выпад структурного программирования был сокрытие информации, идея о том, что реализации код's структура (которая может меняться довольно часто), должны храниться отдельно от интерфейса (который в идеале выиграл't изменить почти столько же). Это'ы догма сейчас, но в былые времена, многие люди действительно считают его лучше для каждого разработчика, чтобы узнать подробности всей системы, так что это был в свое время фактически спорная идея. Оригинальное издание ручей'ы Мифический человеко месяц На самом деле выступал против сокрытия информации.

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

Так на языке Modula-2 и ADA (83) можно объявить любую рутинную, тип, константа или объект в пространстве имен, частная или государственная, но если у вас есть вид записи, нет (простой) способ объявить некоторые записи полей **** общественные и другие частные. Либо вся ваша запись общественный, или он's не.

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

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

Это'ы, наверное, важно подчеркнуть, что ограничение доступа, а также стандартизированное соглашение, а не язык-насильственных строительства работает просто отлично (см. питона). Кроме того, ограничение доступа к полям объекта только когда-либо собирается защищать программиста, когда есть необходимость изменить значение данных внутри объекта после создания. Которые уже запах кода. Возможно, с's и в частности, c++'с сайта `как const для методов и аргументов функции гораздо большую помощь, чем Java программист'ы довольно плохой "финал".

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

Я надеюсь, что это емко ответил на ваш вопрос.

Вот очень простой контр-пример: в Java, интерфейс определим объекты, а `класса, которые не. А "класс" определяет абстрактный тип данных, а не объект.

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