C++: зачем объявлять частные функции?

Question

Почему классы на C++ должны объявлять свои частные функции? Имеет ли это фактические технические причины (какова его роль во время компиляции) или просто для согласованности?

Answer 1

Я спросил, почему частные функции должны были быть объявлены на всех, так как они ничего (ни размер объекта, ни виртуальной таблицы записи) для других единиц перевода знать

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

С точки зрения программиста объявление частных функций по-прежнему не является абсолютно бесполезным. Представьте себе 2 класса, один из которых - friend другого. Дружеский класс должен знать, как выглядят рядовые участники этого класса (это обсуждение становится странным), иначе они не смогут его использовать.

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

Заключительное примечание состоит в том, что private функции могут влиять на размер vtable. То есть, если они virtual.

---

_{На самом деле не совсем. Если у вас встроенные функции в классе, они могут ссылаться на функции, которые позже определены в одном классе. Но, вероятно, идея начиналась с одного прохода, и это исключение позже было добавлено к нему.}

_{Это, в частности, элементы-члены.}

Answer 2

Уровень доступа не влияет на видимость. Частные функции могут видеть внешний код и могут быть выбраны разрешением перегрузки (который затем приведет к ошибке violoation доступа):

class A { 
    void F(int i) {} 
public: 
    void F(unsigned i) {} 
}; 

int main() { 
    A a; 
    a.F(1); // error, void A::F(int) is private 
} 

себе путаницу, когда это работает:

class A { 
public: 
    void F(unsigned i) {} 
}; 

int main() { 
    A a; 
    a.F(1); 
} 

// add private F overload to A 
void A::F(int i) {} 

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

class A { 
public: 
    void F(unsigned i) {} 
}; 

// add private F overload to A 
void A::F(int i) {} 

int main() { 
    A a; 
    a.F(1); 
} 

Или вот еще один пример этого происходит не так:

// A.h 
class A { 
public: 
    void g() { f(1); } 
    void f(unsigned); 
}; 

// A_private_interface.h 
class A; 
void A::f(int); 

// A.cpp 
#include "A_private_interface.h" 
#include "A.h" 

void A::f(int) {} 
void A::f(unsigned) {} 

// main.cpp 
#include "A.h" 

int main() { 
    A().g(); 
} 

Answer 3

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

Если у вас есть метод, который используется только в файле .cpp и не зависит от прямого доступа к другим частным членам класса, подумайте над перемещением его в анонимное пространство имен. Затем его не нужно объявлять в файле заголовка.

Answer 4

Вы должны объявить всех членов в определении самого класса, чтобы компилятор знал, какие функции разрешено быть членами. В противном случае второй программист мог (случайно?) Прийти и добавить членов, совершить ошибки и нарушить гарантии вашего объекта, вызывая неопределенное поведение и/или случайные сбои.

Answer 5

Существует несколько причин, почему частные функции должны быть объявлены.

Первое время компиляции Проверка ошибок

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

Второй Casting и наследование

Взятые из стандарта C++:

3 [Примечание: Член частного базового класса может быть недоступен в качестве унаследованного имени элемента, но доступны непосредственно. Из-за правил конверсий указателей (4.10) и явных приведений (5.4) преобразование из указателя в производный класс в указатель на недоступный базовый класс может быть плохо сформировано, если используется неявное преобразование, но хорошо сформированное если используется явный литой.

3-й Друзья

Друзья показать друг другу там рядовыми. Частный метод может быть вызван другим классом, который является другом.

четвёртая Общие здравомыслие и Good Design

Ever работал над проектом еще 100 разработчиков. Наличие стандартного и общего набора правил помогает поддерживать ремонтопригодность. объявление чего-то частного имеет конкретное значение для всех остальных в группе.

Также это вступает в хорошие принципы проектирования ОО. Что разоблачить и то, что не

Answer 6

Там это сочетание проблем, но:

• C++ не позволяет повторно открыть класс объявить новых членов в нем после его первоначального определения.
• C++ не позволяет вам иметь разные определения класса в разных единицах перевода, которые объединяются для формирования программы.

Поэтому:

• Любых частных функций-членов, что файл .cpp хочет объявленные в классе должен быть определен в файл .h, который каждый пользователь класса видит тоже.

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

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

Возможно, да для обоих. Я не думаю, что есть какие-либо технические препятствия, хотя в настоящее время ODR очень строго о том, что делает определение «отличным» (и, следовательно, очень велико для реализаций, позволяющих бинарную несовместимость между очень похожими определениями). Я думаю, что текст для введения такого исключения в правило будет сложным.

В конечном счете, это может свести к минимуму «дизайнеры хотели этого», или, возможно, кто-то попробовал это и столкнулся с препятствием, о котором я не думал.

Answer 7

Одна из причин заключается в том, что в C++ друзья могут получить доступ к вашим рядовым. Друзья должны получить доступ к ним, друзья должны знать о них.