Что такое зацепление (coupling) в контексте архитектуры ПО?

А, слушай, вот эта тема про зацепление — это, блядь, основа основ, но её так часто на пальцах не объясняют. Сейчас разжуем, чтобы понятно было даже мартышлюшке.

Представь, что твой код — это не программа, а этажерка из стаканов, которую ты собрал на вечеринке. Зацепление (coupling) — это мера того, насколько эти стаканы друг за друга цепляются. Если они все вставлены друг в друга и переплетены проводами — это пиздопроебибна. Чихнёшь на один — и вся конструкция накрывается медным тазом. Высокое зацепление — это и есть эти сильные связи, от которых код становится хрупким, как яичная скорлупа. Тестировать его — волнение ебать, а изменить одну деталь — это терпения ноль ебать, потому что всё развалится. Наша цель — низкое зацепление, когда стаканы стоят отдельно и только кивают друг другу через край стола.

Вот смотри, какие бывают типы этой самой сцепки, от самого дерьмового к более-менее нормульному:

1. Содержательное зацепление (Content Coupling). Это, ёпта, полный пиздец. Один модуль лезет прямо в кишки другого, в его приватные поля, как последний распиздяй. Нарушение инкапсуляции в чистом виде.

   // ПЛОХО: Класс A ведёт себя как хитрая жопа и лезет в приватные поля класса B.
   class B { private: int secret; };
   class A { void hack(B& b) { b.secret = 42; } }; // Нарушение! Прямой доступ, доверия ебать ноль.

   Видишь? Класс A — тот ещё ебанько, он думает, что ему всё можно. Так делать — себя не уважать.

2. Общее зацепление (Common Coupling). Тут модули общаются через какую-то глобальную помойку — переменную, к которой все имеют доступ. Представь, что у тебя в комнате одна кружка на всех. Один выпил, другой долил непойми чего — и понеслась. Удивление пиздец гарантировано.

   // ПЛОХО: Глобальная переменная как общая помойка для связи.
   extern int globalState; // Эта штука видна всем, как хуй с горы.
   void module1() { globalState = 1; }
   void module2() { if (globalState == 1) { /*...*/ } } // А module2 теперь зависит от того, что натворил module1.

   Кто угодно может globalState изменить, и отследить, откуда ноги растут — это ебать копать.

3. Управляющее зацепление (Control Coupling). Чуть получше, но тоже не сахар. Один модуль тычет другому в морду флагом, говоря: «Сделай то-то, если я сказал». Это как давать команду коту сука собака: он может сделать, а может и послать тебя.

   // НЕИДЕАЛЬНО: Функция делает разную работу в зависимости от флага. Подозрение ебать чувствую.
   void processData(Data& data, bool shouldNormalize); // А что, если флагов станет 5? Функция превратится в манда с ушами.

4. Зацепление по данным (Data Coupling). А вот это, блядь, красота! То, к чему надо стремиться. Модули общаются чётко, как на почте: передают только необходимые данные через параметры и больше нихуя. Никаких сюрпризов.

   // ХОРОШО: Чёткий интерфейс, минимальная зависимость. Как будто передал деньги и получил чек.
   double calculateTax(const Order& order); // Функция берёт заказ, делает свои дела и возвращает налог. Всё. Чих-пых тебя в сраку, просто и понятно.

Так в чём же принцип, спросишь ты? А принцип, чувак, в том, чтобы гнаться к слабому зацеплению и при этом к сильной связности (high cohesion) внутри самого модуля. Это значит, что всё, что находится внутри одного класса или функции, должно быть связано одной логикой, одной ответственностью. Как будто у тебя бригада: внутри все свои, работают слаженно (сильная связность), а с другими бригадами общаются только через прораба и по делу (слабое зацепление). Делаешь так — и жить становится проще, а код не разваливается от одного чиха.