Другие решения
Вы должны объявить вашу переменную ‘dim’ следующим образом:
Без квалификатора constexpr. Затем в global.cpp вы можете создать его так:
Или вот так:
Любой из них будет работать, потому что компилятор способен понять, что второй неявно является constexpr.
Вы можете использовать квалификатор constexpr только в том случае, если вы собираетесь вычислить значение в том же выражении.
Однако для вашей конкретной проблемы я бы порекомендовал использовать перечисление:
Перечисления являются чистыми константами времени компиляции и не занимают места во время выполнения (если вы не присваиваете переменным их значения), и прекрасно работают в заголовках. Это конкретное перечисление является анонимным перечислением, то есть оно не имеет имени и имеет только одно значение — dimm.
1
Я действительно надеюсь, что вы видите это и не двинулись дальше со своей жизнью.
Это определенно хорошая практика — определять ваши постоянные данные в заголовке и использовать их во всем приложении. То же самое относится и к некоторым статическим функциям, которые вы используете во всем приложении; Вы можете создать создайте заголовок и сохраните свои служебные функции (что-то печатая, математические формулы, которые вы используете в общем и т. д.) и используйте этот заголовок везде Включение ваших собственных заголовков в другие заголовки не отличается от включения заголовков, написанных другими людьми (такими как ).
Лично мне не нравится но у меня нет веских аргументов против этого, просто предпочтение. Для меня, это более общая вещь, чтобы использовать и в значительной степени означает, , Когда вы используете вы в основном говорите компилятору скопировать определенное значение в то место, где оно используется. Пример:
Компилятор меняет MAX_NUMBER на все, что вы кладете рядом с ним. Это буквально копирование и вставка.
Вот подвох, не используйте в вашем коде (особенно в вашем глобальном объявлении или служебных заголовках). буквально получает весь контент пространства имен и вставляет его туда, где он его видит. Это вызывает все виды проблем, это полностью система пространства имен и особенно в больших базах кода, это заставляет других разработчиков время от времени ненавидеть вас.
Большую часть времени люди используют писать а также Быстрее. Для этого вы можете изменить в
который делает то же самое, но получает только те функции из пространства имен, а не все в нем.
1
Я обнаружил, что самое простое, что также является неплохой практикой программирования, это:
Вот ссылка на ответ, который я получил:
Защита заголовков не препятствует одиночным включениям заголовка в разные файлы исходного кода.
Обратите внимание, что цель защиты заголовков – предотвратить получение файлом исходного кода более одной копии защищенного заголовка. По замыслу, защита заголовков не препятствует включению данного заголовочного файла (однократно) в отдельные исходные файлы
Это также может вызвать непредвиденные проблемы. Рассмотрим следующую возможность:
square.h:
square.cpp:
main.cpp:
Обратите внимание, что square.h включается как из main.cpp, так и из square.cpp. Это означает, что содержимое square.h будет включено один раз в square.cpp и один раз в main.cpp
Давайте разберемся, почему это происходит более подробно. Когда square.h включается из square.cpp, определяется до конца square.cpp. Это определение предотвращает повторное включение square.h в square.cpp (что является целью защиты заголовков). Однако после завершения square.cpp больше не считается определенным. Это означает, что когда препроцессор начинает работу над main.cpp, в main.cpp изначально не определен.
Конечным результатом является то, что и square.cpp, и main.cpp получают копию определения . Эта программа будет компилироваться, но компоновщик будет жаловаться на то, что ваша программа имеет несколько определений для идентификатора !
Лучший способ обойти эту проблему – просто поместить определение функции в один из файлов .cpp, чтобы заголовок содержал только предварительное объявление:
square.h:
square.cpp:
main.cpp:
Теперь, когда программа скомпилирована, функция будет иметь только одно определение (через square.cpp), так что компоновщик будет счастлив. Файл main.cpp может вызывать эту функцию (даже если она находится в square.cpp), потому что он включает square.h, в котором есть предварительное объявление для этой функции (компоновщик соединит вызов из main.cpp с определение в square.cpp).
Не нарушает ли определение функций-членов в заголовке правило одного определения?
По-разному. Функции-члены, определенные внутри определения класса, считаются неявно встраиваемыми (inline). Встраиваемые (inline) функции освобождаются от правила одного определения относительно одного определения в программе. Это означает, что нет проблем с определением тривиальных функций-членов (таких как функции доступа) внутри определения самого класса.
Функции-члены, определенные вне определения класса, обрабатываются как обычные функции и подчиняются правилу одного определения относительно одного определения в программе. Следовательно, эти функции должны быть определены в файле исходного кода, а не внутри заголовка. Единственным исключением являются шаблоны функций, о которых мы поговорим в следующей главе.
Configuring Style with clang-format¶
clang-format supports two ways to provide custom style options:
directly specify style configuration in the command line option or
use and put style configuration in the or
file in the project directory.
When using , clang-format for each input file will
try to find the file located in the closest parent directory
of the input file. When the standard input is used, the search is started from
the current directory.
The file uses YAML format:
key1 value1 key2 value2 # A comment. ...
The configuration file can consist of several sections each having different
parameter denoting the programming language this section of the
configuration is targeted at. See the description of the Language option
below for the list of supported languages. The first section may have no
language set, it will set the default style options for all languages.
Configuration sections for specific language will override options set in the
default section.
When clang-format formats a file, it auto-detects the language using
the file name. When formatting standard input or a file that doesn’t have the
extension corresponding to its language, option can be
used to override the file name clang-format uses to detect the
language.
An example of a configuration file for multiple languages:
--- # We'll use defaults from the LLVM style, but with 4 columns indentation. BasedOnStyle LLVM IndentWidth 4 --- Language Cpp # Force pointers to the type for C++. DerivePointerAlignment false PointerAlignment Left --- Language JavaScript # Use 100 columns for JS. ColumnLimit 100 --- Language Proto # Don't format .proto files. DisableFormat true --- Language CSharp # Use 100 columns for C#. ColumnLimit 100 ...
An easy way to get a valid file containing all configuration
options of a certain predefined style is:
clang-format -style=llvm -dump-config > .clang-format
When specifying configuration in the option, the same configuration
is applied for all input files. The format of the configuration is:
Зачем нужны заголовочные файлы
В языке C существует соглашение, идущее из основополагающей книги Кернигана и Ритчи, о том, что в месте первого вызова любой функции компилятор должен «знать» тип аргументов и возвращаемого значения функции. В C++ это соглашение было превращено в требование языка. Как показывает практика это соглашение помогает избежать многих нетривиальных ошибок.
Указанное требование тривиально выполняется в простых случаях наподобие (считается, что компилятор просматривает программу сверху-вниз один раз — что, вообще говоря, неверно для современных компиляторов):
void f(int a) { /* ... */ }
int main() {
f(5);
}
Однако если программу немного изменить, то требование уже нарушится:
int main() {
f(5);
}
void f(int a) { /* ... */ }
Хотя в остальном эта программа вполне корректна. В случаях, когда такой порядок определения функций (сначала main, потом f) по какой-то причине более предпочтителен, можно использовать специальный элемент языка, называемый объявлением или прототипом функции f:
void f(int a);
int main() {
f(5);
}
void f(int a) { /* ... */ }
Объявление в первой строке сообщает компилятору, что вызовы функции f в дальнейшем тексте предполагают, что
эта функция принимает один аргумент типа int и возвращает void.
Объявления следует также использовать, когда одна функция (например, main) вызывает другую (например, f), и при этом вторая функция определена в отдельном исходном файле.
Если функция определена в отдельном файле, то она может использоваться во многих других файлах, и в каждом таком файле придётся добавлять её объявление. Заголовочный файл представляет собой место, где собирается информация, которая возможно потребуется многим другим файлам. Объявления функций представляют классический пример такой информации. Директива препроцессора наподобие
#include "myFunctions.h"
вставляет целиком содержимое указанного заголовочного файла в текущее место исходного файла перед компиляцией (например, в main.c, если в нём встретилась эта строка). После такой вставки в main.c окажутся все объявления функций из файла myFunctions.h и компилятор будет счастлив.
Создание заголовочных файлов
Продолжим разбирать приведенную выше программу. Что будет, если в функции осуществить неправильный вызов функций и ? Например, указать неверное количество параметров. В таком случае создание объектных файлов пройдет без ошибок, и скорее всего удастся получить исполняемый файл; но вот работать программа будет неправильно. Такое возможно потому, что ничего не контролирует соответствие вызовов прототипам (объявлениям) функций.
Куда правильней сообщать о неверном вызове функций уже при получении объектного файла. Поэтому хотя можно обойтись и без этого, но очень желательно сообщать функции прототипы функций, которые из нее вызываются. Это можно сделать, прописав объявления функций в файле main.c:
…
void l2r (char **c, int n);
void r2l (char **c, int n);
main () {
…
Теперь, если мы передадим неправильные параметры, ошибка возникнет уже на этапе получения объектных файлов.
А теперь представим, что программа у нас несколько больше и содержит десяток файлов исходного кода. Файл aa.c требует функций из файла bb.c, dd.c, ee.c. В свою очередь dd.c вызывает функции из ee.c и ff.c, а эти два последних файла активно пользуются неким файлом stars.c и одной из функций в bb.c. Программист замучится сверять, что чего вызывает откуда и куда, где и какие объявления надо прописывать. Поэтому все прототипы (объявления) функций проекта, а также совместно используемые символические константы и макросы выносят в отдельный файл, который подключают к каждому файлу исходного кода. Такие файлы называются заголовочными; с ними мы уже не раз встречались. В отличие от заголовочных файлов стандартной библиотеки, заголовочные файлы, которые относятся только к вашему проекту, при подключении к файлу исходного кода заключаются в кавычки, а не скобки. Об этом упоминалось в предыдущем уроке.
Итак, более грамотно будет не добавлять объявления функций в файл main.c, а создать заголовочный файл, например, myprint.h и поместить туда прототипы функций и . А в файле следует прописать директиву препроцессора:
#include "myprint.h"
В принципе смысла подключать myprint.h к файлу superprint.c в данном случае нет, т.к. последний не использует никаких сторонних функций, кроме стандартной библиотеки. Но если планируется расширять программу и есть вероятность, что в файле superprint.c будут вызываться сторонние для него функции, то будет надежней сразу подключить заголовочный файл.
Обратим внимание еще на один момент. Стоит ли в описанном в этом уроке примере выносить константу N в заголовочный файл? Здесь нельзя дать однозначный ответ
Если ее туда вынести, то она станет доступна в обоих файлах, и поэтому можно изменить прототипы функций так, чтобы они принимали только один параметр (указатель), а значение N будет известно функциям их заголовочного файла. Однако стоит ли так делать? В функции второй параметр изменяется в процессе ее выполнения, что делать с константой будет невозможно. Придется переписывать тело функции. Кроме того, вдруг в последствии нам захочется использовать файл superprint.c в другом проекте, где будут свои порядки, и константы N в заголовочном файле не найдется.
В таком случае лучше N не выносить в заголовочный файл. Хотя имейте в виду, в каких-то проектах символическая константа может использоваться так часто и во множестве функций, что ее будет лучше поместить в заголовочный файл.
Определение функций-членов вне определения класса
Все классы, которые мы написали на данный момент, были достаточно простыми, чтобы мы могли реализовать функции-члены непосредственно внутри определения самого класса. Например, вот наш вездесущий класс :
Однако по мере того, как классы становятся длиннее и сложнее, наличие всех определений функций-членов внутри класса может затруднить управление классом и работу с ним. Использование уже написанного класса требует понимания только его открытого интерфейса (общедоступных функций-членов), а не понимания того, как класс работает под капотом. Детали реализации функций-членов просто мешают.
К счастью, C++ предоставляет способ отделить часть «объявления» класса от его «реализации». Это делается путем определения функций-членов класса вне определения класса. Для этого просто определите функции-члены класса, как если бы они были обычными функциями, но добавив к функциям префикс из имени класса с помощью оператора разрешения области видимости () (так же, как для пространства имен).
Вот наш класс с конструктором и функцией , определенными вне определения класса
Обратите внимание, что прототипы этих функций всё еще присутствуют внутри определения класса, но фактическая реализация вынесена за его пределы:. Это довольно просто
Поскольку функции доступа часто представляют собой только одну строку, они обычно остаются в определении класса, даже если их можно переместить за его пределы
Это довольно просто. Поскольку функции доступа часто представляют собой только одну строку, они обычно остаются в определении класса, даже если их можно переместить за его пределы.
Вот еще один пример, который включает внешний конструктор со списком инициализации членов.
Было:
Стало:
Header guards
На самом деле решение простое — использовать header guards (защиту подключения в языке C++). Header guards — это директивы , которые состоят из следующего:
#ifndef SOME_UNIQUE_NAME_HERE
#define SOME_UNIQUE_NAME_HERE
// Основная часть кода
#endif
|
1 |
#ifndef SOME_UNIQUE_NAME_HERE // Основная часть кода #endif |
Если подключить этот заголовочный файл, то первое, что он сделает — это проверит, был ли ранее определен идентификатор . Если мы впервые подключаем этот заголовок, то еще не был определен. Следовательно, мы определяем (с помощью директивы #define) и выполняется основная часть заголовочного файла. Если же мы раньше подключали этот заголовочный файл, то уже был определен. В таком случае, при подключении этого заголовочного файла во второй раз, его содержимое будет проигнорировано.
Все ваши заголовочные файлы должны иметь header guards. может быть любым идентификатором, но, как правило, в качестве идентификатора используется имя заголовочного файла с окончанием . Например, в файле math.h идентификатор будет :
math.h:
#ifndef MATH_H
#define MATH_H
int getSquareSides()
{
return 4;
}
#endif
|
1 |
#ifndef MATH_H intgetSquareSides() { return4; } #endif |
Даже заголовочные файлы из Стандартной библиотеки С++ используют header guards. Если бы вы взглянули на содержимое заголовочного файла iostream, то вы бы увидели:
#ifndef _IOSTREAM_
#define _IOSTREAM_
// основная часть кода
#endif
|
1 |
#ifndef _IOSTREAM_ // основная часть кода #endif |
Но сейчас вернемся к нашему примеру с math.h, где мы попытаемся исправить ситуацию с помощью header guards:
math.h:
#ifndef MATH_H
#define MATH_H
int getSquareSides()
{
return 4;
}
#endif
|
1 |
#ifndef MATH_H intgetSquareSides() { return4; } #endif |
geometry.h:
#include «math.h»
| 1 | #include «math.h» |
main.cpp:
#include «math.h»
#include «geometry.h»
int main()
{
return 0;
}
|
1 |
#include «math.h» intmain() { return; } |
Теперь, при подключении в main.cpp заголовочного файла math.h, препроцессор увидит, что не был определен, следовательно, выполнится директива определения и содержимое math.h скопируется в main.cpp. Затем main.cpp подключает заголовочный файл geometry.h, который, в свою очередь, подключает math.h. Препроцессор видит, что уже был ранее определен и содержимое geometry.h не будет скопировано в main.cpp.
Вот так можно бороться с дублированием определений с помощью header guards.
Типичные ошибки
Ошибка 1. Определение в заголовочном файле.
Эта ошибка в некоторых случаях может себя не проявлять. Например, когда заголовочный файл с этой ошибкой включается только один раз. Но как только этот заголовочный файл будет включён более одного раза, получим либо ошибку компиляции «многократное определение символа …», либо ошибку компоновщика аналогичного содержания, если второе включение было сделано в другой единице компиляции.
Ошибка 2. Отсутствие защиты от повторного включения заголовочного файла.
Тоже проявляет себя при определённых обстоятельствах. Может вызывать ошибку компиляции «многократное определение символа …».
Ошибка 3. Несовпадение объявления в заголовочном файле и определения в файле реализации.
Обычно возникает в процессе редактирования исходного кода, когда в файл реализации вносятся изменения, а про заголовочный файл забывают.
Ошибка 4. Отсутствие необходимой директивы .
Если необходимый заголовочный файл не включён, то все сущности, которые в нём объявлены, останутся неизвестными компилятору. Вызывает ошибку компиляции «не определён символ …».
Ошибка 5. Отсутствие необходимого модуля в проекте построения программы.
Вызывает ошибку компоновки «не определён символ …»
Обратите внимание, что имя символа в сообщении компоновщика почти всегда отличается от того, которое определено в программе: оно дополнено другими буквами, цифрами или знаками
Ошибка 6. Зависимость от порядка включения заголовочных файлов.
Не совсем ошибка, но таких ситуаций следует избегать. Обычно сигнализирует либо об ошибках в проектировании программы, либо об ошибках при разделении исходного кода на модули.
Пояснения по тексту программы урока
Представленная программа состоит из трех функций. Ранее уже говорилось, что точкой входа в приложение является функция main() с определенной сигнатурой, а программа может состоять из любого количества функций.
Сигнатуру функции (от англ. signature — подпись, нечто идентифицирующее) в языке C++, определяет не только имя функции, но и тип параметров вызова функции, а также, тип, который функция возвращает.
Понятие сигнатуры функции важно для создания библиотек функций, так как требуется механизм идентификации функций, хранимых в библиотеках. Проблема языка C++, в данном контексте, связана с тем, что язык C++ допускает перегрузку имен функций, т.е
возможно существование любого количества функций с одним именем, но с различным списком параметров функций. Прочитайте в учебнике о правилах перегрузки функций в языке C++, а к понятию сигнатуры мы вернемся при рассмотрении темы создания библиотек.
Ничего особенного в трех функциях представленного примера нет. Предполагается, что общие сведения по синтаксису и основным элементам языка C++ у вас уже есть или вы изучаете их по какому-нибудь учебнику. Внимания, возможно, заслуживает только строки 21-23 записи цикла for. Вообще, цикл for в языке C++ имеет интересные особенности. Особенно для тех, кто пришел в язык C++ из Pascal или Fortran. Дополнительную особенность, указанным строкам, придает использование операторов «запятая». Сама шапка цикла for, состоит из трех частей, которые разделяются через символ «точка с запятой». Подробности записи оператора for следует прочитать в учебнике. Для сравнения, приведем четыре часто используемых формы записи цикла for.
// Обычный цикл по параметру
for (int i=0; i<n; ++i) { ... }
// Цикл обхода списка по итератору
std::list<T> ls;
...
for (std::list<T>::iterator it=ls.begin(); it != ls.end(); ++it) { ... }
// Еще один, часто используемый, вариант записи обхода списка по итератору
std::list<T> ls;
...
std::list<T>::const_iterator it=ls.begin();
for ( ; it != ls.end(); ++it) { ... }
// "Бесконечный" цикл. Внутри цикла, по выполнении какого-то условия выполняется break.
for(;;) { ... break; ...}
Не следует сейчас углубляться в понимание синтаксиса элементов использованных во второй и третьей записи цикла — они требуют знания объектно-ориентированного программирования (ООП), обобщенного программирования (ОП) и шаблонов классов-контейнеров из стандартной библиотеки STL. Главное здесь — увидеть в шапке цикла раздел инициализации, раздел проверки выполнения следующей итерации и раздел выполняющийся по завершении каждой из итераций. Каждый из разделов может быть пустым, а может содержать в себе оператор «запятую», который группирует операторы выполняющиеся слева направо.
Проблема повторяющегося определения
В уроке «2.6 – Предварительные объявления и определения» мы отметили, что идентификатор переменной или функции может иметь только одно определение (правило одного определения). Таким образом, программа, которая определяет идентификатор переменной более одного раза, вызовет ошибку компиляции:
Точно так же программы, которые определяют функцию более одного раза, также вызовут ошибку компиляции:
Хотя эти программы легко исправить (удалить повторяющееся определение), с помощью заголовочных файлов довольно легко попасть в ситуацию, когда определение в заголовочный файл включается более одного раза. Это может произойти, если заголовочный файл включает с другой заголовочный файл (что является обычным явлением).
Рассмотрим следующий академический пример:
square.h:
geometry.h:
main.cpp:
Эта, казалось бы, невинно выглядящая программа не компилируется! Вот что происходит. Во-первых, main.cpp включает square.h, что копирует определение функции в main.cpp. Затем main.cpp включает geometry.h, который сам включает square.h. Это копирует содержимое square.h (включая определение функции ) в geometry.h, которое затем копируется в main.cpp.
Таким образом, после разрешения всех директив файл main.cpp будет выглядеть так:
Повторяющиеся определения и ошибка компиляции. Каждый файл по отдельности нормальный. Однако, поскольку main.cpp дважды включает через содержимое square.h, мы столкнулись с проблемами. Если для geometry.h требуется , а для main.cpp требуются и geometry.h, и square.h, как бы вы решили эту проблему?
‘CLASS_MEMBER’ is private within this context[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- usually reported in the format:
- (LOCATION_OF_PRIVATE_DATA_MEMBER) error: ‘DATA_MEMBER’ is private
- (LOCATION_OF_CODE_ACCESSING_PRIVATE_DATA) error: within this context
- Message usually results from trying to access a private data member of a class or struct outside that class’s or struct’s definition
- Make sure a friend member function name is not misspelled
class FooBar{
privateintbar;
publicfriendvoidfoo(FooBar&f);
};
voidfooo(FooBar&f){// error
f.bar=;
}
- make sure a read only function is using a ‘const’ argument type for the class
- make sure functions that alter data members are not const
- check for derived class constructors implicitly accessing private members of base classes
class Foo{
privateFoo(){}
publicFoo(intNum){}
};
class BarpublicFoo{
publicBar(){}
// Bar() implicitly accesses Foo's private constructor
};
- solution 1: use an initializer list to bypass implicit initialization
- solution 2: make the accessed base class member protected instead of private
You’re trying to initialize a contained class member by accessing private data
class Foo{
privatecharmrStr5];
publicFoo(constchar*s="blah"){strcpy(mrStr,s);}
};
class Bar{
private
intmrNum;
FooaFoo;
public
Bar(intn,constFoo&f);
};
// error, attempting to use the Foo class constructor by accessing private data:
Bar::Bar(intn,constFoo&f)aFoo(f.mrStr){// mrStr is private
mrNum=n;
}
possible fix, assign the whole object rather than part of it:
Bar::Bar(intn,constFoo&f)aFoo(f){
mrNum=n;
}
Особенности использования глобальных переменных
Помните, если можно отказаться от использования глобальных переменных, то лучше это сделать. Желательно стремиться к тому, чтобы любой файл проекта, скажем так, «не лез к соседу за данными, а сосед не разбрасывал эти данные в виде глобальных переменных». Обмен данными между функциями должен осуществлять за счет передачи данных в качестве параметров и возврата значений с помощью оператора . (Массивов это не касается.)
Однако в языке программирования C есть проблема. С помощью можно вернуть только одно значение. Но могут быть случаи, когда функция должна изменить несколько переменных (здесь не имеются ввиду элементы массива). В таком случае без глобальных переменных обойтись сложно.
- Если в файле aa.c объявлена переменная за пределами любой функции (например, так: ), то она является глобальной для всех файлов проекта. Чтобы получить значение этой переменной в файле aa.c достаточно просто указать ее имя (если в функции нет локальной переменной с тем же именем). Чтобы получить значение из других файлов, надо указать, что имеется в виду глобальная переменная, а не локальная. Делается это с помощью ключевого слова (например, ).
- Бывают ситуации, когда в одном файле для нескольких содержащихся в нем функций нужна глобальная переменная. Но эта переменная не должна быть доступна функциям, содержащимся в других файлах. В таком случае глобальная переменная объявляется с ключевым словом (например, ). Тем самым мы как бы скрываем глобальную переменную.
Напишите простые наглядные примеры, использования глобальных функций:
- Объявите глобальную переменную в одном файле, а получите ее значение в другом файле (выведите на экран).
- Объявите в одном файле статическую глобальную переменную. Выведите ее значение на экран из функции данного файла. Попытайтесь сделать это из функции другого файла.
- Создайте две глобальные переменные в одном файле. В другом файле напишите функцию, которая меняет их значение.
Текст программы урока
Рассмотрим следующую программу. Не следует искать в программе какой-то сокровенный смысл, так как это не более чем попытка соответствовать теме урока. Как и прежде, следует помнить, что номера строк не должны быть в файле с текстом программы и приведены только для упрощения комментариев к коду.
01. #include <iostream>
02.
03. int addUpToLimit(int op1, int op2)
04. {
05. int res = op1+op2;
06. if (res>100) res = 100;
07. return res;
08. }
09.
10. int incrementator(int value)
11. {
12. return addUpToLimit(value, 8);
13. }
14.
15. int main(int argc, char *argv[])
16. {
17. int n = 0;
18.
19. n = addUpToLimit(n, 20);
20. int counter = 0;
21. for (int m = 0, delta = m-n;
22. delta!=0;
23. m = incrementator(n), delta = m-n, n = m, ++counter);
24.
25. std::cout << "Cycle counter = " << counter << std::endl;
26.
27. return 0;
28. }
Для определенности, запишем эти строки в файл main.cpp. В этом случае, простейшая команда для компиляции файла такой программы будет выглядеть следующим образом.
$ g++ main.cpp
В результате выполнения такой команды под операционной системой Linux получится файл a.out, который можно будет запустить следующим образом.
$ ./a.out
9 ответов
Лучший ответ
Объяснение предполагает, что существует некая разумная реализация для , которая возвращает ссылку lvalue на действительный .
Такой реализацией может быть:
Теперь, поскольку возвращает ссылку на lvalue, мы можем присвоить что-нибудь возвращаемому значению, например:
Это обновит глобальный значением , которое мы можем проверить, обратившись к переменной напрямую или снова вызвав :
168
TartanLlama
13 Апр 2016 в 07:25
Объявляет функцию с именем foo, которая возвращает ссылку на . Эти примеры не позволяют дать вам определение функции, которую вы могли бы скомпилировать. Если мы используем
Теперь у нас есть функция, которая возвращает ссылку на . так как bar равен , он будет продолжать работать после вызова функции, поэтому возврат ссылки на него безопасен. Теперь, если мы сделаем
Что происходит, мы назначаем 42 для , поскольку мы назначаем ссылку, а ссылка является просто псевдонимом для . Если мы снова вызовем функцию, например
Он напечатает 42, поскольку мы установили на это выше.
32
NathanOliver
7 Апр 2016 в 13:29
объявляет функцию с именем с типом возврата . Если вы вызовете эту функцию без указания тела, вы, вероятно, получите ошибку неопределенной ссылки.
Во второй попытке вы предоставили функцию . Это имеет другой тип возвращаемого значения по сравнению с функцией, объявленной . Итак, у вас есть два объявления одного и того же , которые не совпадают, что нарушает правило одного определения, вызывая неопределенное поведение (диагностика не требуется).
Для чего-то, что работает, удалите объявление локальной функции. Как вы видели, они могут вести к бесшумному неопределенному поведению. Вместо этого используйте только объявления функций вне какой-либо функции. Ваша программа могла бы выглядеть так:
15
M.M
7 Апр 2016 в 13:29
означает, что возвращает ссылку на переменную.
Рассмотрим этот код:
Этот код печатает:
$ ./a.out k = 5
Поскольку возвращает ссылку на глобальную переменную .
В пересмотренном коде вы приводите возвращаемое значение к ссылке, которая в таком случае недействительна.
7
vy32
7 Апр 2016 в 13:28
Пример кода на связанной странице — это просто объявление фиктивной функции. Он не компилируется, но если бы у вас была определена какая-то функция, она работала бы в целом. Пример означал: «Если у вас есть функция с этой подписью, вы можете использовать ее так».
В вашем примере явно возвращает lvalue на основе подписи, но вы возвращаете rvalue, преобразованное в lvalue. Это явно обречено на провал. Вы могли сделать:
И преуспеет, изменив значение x, когда скажет:
4
Peter Mortensen
8 Апр 2016 в 22:01
— это функция, возвращающая ссылку на . Предоставленная вами функция возвращает без ссылки.
Вы можете сделать
10
Peter Mortensen
8 Апр 2016 в 22:00
В этом контексте & означает ссылку, поэтому foo возвращает ссылку на int, а не на int.
Я не уверен, что вы еще работали с указателями, но идея аналогична, вы фактически не возвращаете значение из функции — вместо этого вы передаете информацию, необходимую для поиска места в памяти, где это int есть.
Итак, чтобы подвести итог, вы не присваиваете значение вызову функции — вы используете функцию для получения ссылки, а затем присваиваете значение, на которое ссылается, новому значению. Легко представить, что все происходит сразу, но на самом деле компьютер делает все в точном порядке.
Если вам интересно — причина, по которой вы получаете segfault, заключается в том, что вы возвращаете числовой литерал ‘2’ — так что это точная ошибка, которую вы получили бы, если бы вы определяли const int, а затем пытались изменить его значение.
Если вы еще не узнали об указателях и динамической памяти, я бы порекомендовал это в первую очередь, так как есть несколько концепций, которые, как мне кажется, трудно понять, если вы не изучите их все сразу.
5
Brett
7 Апр 2016 в 13:36
У вас есть функция foo (), которая возвращает ссылку на целое число.
Итак, предположим, что изначально foo вернул 5, а позже в своей основной функции вы скажете , затем распечатаете foo, он выведет 10 вместо 5.
Надеюсь это имеет смысл 
Я тоже новичок в программировании. Интересно видеть такие вопросы, которые заставляют задуматься!
3
Peter Mortensen
8 Апр 2016 в 22:03
Все остальные ответы объявляют статику внутри функции. Я думаю, это может вас запутать, поэтому взгляните на это:
Поскольку возвращает ссылку, вы можете присвоить ей значение. Когда это выполняется, будет изменено на 11. Если вы изменили инициализацию так, чтобы было, скажем, 8, тогда будет изменено на 11. Это некоторый код, который может действительно служить цели, в отличие от других примеров.
73
Kate Gregory
7 Апр 2016 в 22:08
Итак, что я должен определять в файле заголовка, а что в файле .cpp,и что внутри определения класса, а что вне его?
У вас может возникнуть соблазн поместить все определения ваших функций-членов в заголовочный файл внутри класса. Хотя это будет компилироваться, у этого подхода есть несколько недостатков. Во-первых, как упоминалось выше, это загромождает определение вашего класса. Во-вторых, если вы измените что-либо в коде в заголовке, вам придется перекомпилировать каждый файл, который включает этот заголовок. Это может иметь волновой эффект, когда одно незначительное изменение вызывает необходимость перекомпиляции всей программы (что может быть медленным). Если вы измените код в файле .cpp, необходимо будет перекомпилировать только этот файл .cpp!
Поэтому мы рекомендуем следующее:
- классы, используемые только в одном файле, и которые, как правило, нельзя использовать повторно, определяйте непосредственно в том файле .cpp, где они используются;
- классы, используемые в нескольких файлах или предназначенные для повторного использования, определяйте в файле .h с тем же именем, что и класс;
- тривиальные функции-члены (тривиальные конструкторы или деструкторы, функции доступа и т.д.) могут быть определены внутри класса;
- нетривиальные функции-члены должны быть определены в файле .cpp с тем же именем, что и класс.
В будущих уроках большинство наших классов будет определено в файле .cpp, а все функции будут реализованы непосредственно в определении класса. Это сделано для удобства и для краткости примеров. В реальных проектах классы гораздо чаще помещаются в их собственные исходные и заголовочные файлы, и вы должны привыкнуть к этому.
Заключение
В рамках небольшой статьи невозможно рассмотреть все случаи, возникающие при раздельной компиляции. Бывают ситуации, когда разделение программы или большого модуля на более мелкие кажется невозможным. Обычно это бывает, когда программа плохо спроектирована (в данном случае, части кода имеют сильные взаимные связи). Конечно, можно приложить дополнительные усилия и всё-таки разделить код на модули (или оставить как есть), но эту мозговую энергию лучше потратить более эффективно: на изменение структуры программы. Это принесёт в дальнейшем гораздо большие дивиденды, чем просто силовое решение.
Cranium aka Череп
