В компьютерном программировании константа является значением , который не может быть изменен программой во время нормального выполнения, т. Е. Значение является постоянным. Когда константа связана с идентификатором, она называется «именованной», хотя термины «константа» и «именованная константа» часто используются взаимозаменяемо. Это контрастирует с переменной, которая представляет собой идентификатор со значением, которое может быть изменено во время нормального выполнения, то есть значение является переменным. Константы полезны как для программистов, так и для компиляторов: для программистов они представляют собой форму самодокументированного кода и позволяют рассуждать о правильности, тогда как для компиляторов они позволяют во время компиляции и во время выполнения проверки, которые подтверждают, что допущения постоянства не нарушаются, и позволяют или упрощают некоторые оптимизации компилятора.
Существуют различные конкретные реализации общего понятия константы с тонкими различия, которые часто упускаются из виду. Наиболее важными из них являются: константы времени компиляции (со статическими значениями), константы времени выполнения (с динамическими значениями), неизменяемые объекты и типы констант (const ).
Константы. Ключевое слово const. C++ для начинающих. Урок #6.
Типичные примеры констант времени компиляции включают математические константы, значения из стандартов (здесь максимальная единица передачи ) или значения внутренней конфигурации (здесь символов в строке ), такие как эти примеры C:
const float PI = 3.1415927; // максимальная точность с плавающей запятой const unsigned int MTU = 1500; // Ethernet v2, RFC 894 const unsigned int COLUMNS = 80;
Типичными примерами постоянных времени выполнения являются значения, вычисленные на основе входных данных функции, например, этот пример C ++:
void f (std :: string s)
Использование
Некоторое программирование языки проводят явное синтаксическое различие между символами констант и переменных, например, рассматривая присвоение константе как синтаксическую ошибку, в то время как в других языках они считаются синтаксически одинаковыми (оба просто идентификатора), и различие в обработке является семантическим (присвоение идентификатора синтаксически допустимо, но если идентификатор является константой, он семантически недопустим).
Значение константы определяется один раз, и на него можно ссылаться много раз в программе. Использование константы вместо указания одного и того же значения несколько раз может упростить сопровождение кода (как в не повторяйтесь ) и может быть самодокументированным путем предоставления значимого имени для значения, например, PI вместо 3.1415926.
Сравнение с литералами и макросами
Есть несколько основных способов выразить значение данных, которое не изменяется во время выполнения программы, которые согласованы в большом количестве языков программирования. Один из самых простых способов — просто записать литерал число, символ или строку в программный код, что просто на C, C ++ и подобных языках.
Программирование 1С. Урок 3. Объекты 1С. Константы
В языке ассемблера буквальные числа и символы выполняются с использованием инструкций «немедленного режима», доступных на большинстве микропроцессоров. Название «немедленно» происходит от значений, доступных немедленно из потока инструкций , в отличие от их косвенной загрузки путем поиска адреса памяти. С другой стороны, значения длиннее, чем длина слова микропроцессора, такие как строки и массивы, обрабатываются косвенно, и ассемблеры обычно предоставляют псевдооперацию «данные» для встраивания таких таблиц данных в программу.
Другой способ — определить символический макрос . Многие языки программирования высокого уровня и многие ассемблеры предлагают средство макроса, в котором программист может определять, как правило, в начале исходного файла или в отдельном файле определения имена для различных значений. Затем препроцессор заменяет эти имена соответствующими значениями перед компиляцией, в результате чего получается нечто функционально идентичное использованию литералов, с преимуществами скорости немедленного режима. Поскольку может быть трудно поддерживать код, в котором все значения записаны буквально, если значение используется каким-либо повторяющимся или неочевидным образом, это часто делается как макрос.
Третий способ — объявить и определить переменную как «постоянную». Глобальная или статическая переменная может быть объявлена (или символ, определенный в сборке) с квалификатором ключевого слова, например const , constant или final , что означает, что ее значение будет установлено во время компиляции и не должно быть изменено во время выполнения. Компиляторы обычно помещают статические константы в текстовый раздел объектного файла вместе с самим кодом, в отличие от раздела данных, в котором хранятся неконстантные инициализированные данные. Некоторые компиляторы могут создавать раздел, специально посвященный константам. К этой области можно применить защиту памяти, чтобы предотвратить перезапись таких констант ошибочными указателями.
Эти константы во многом отличаются от литералов. Компиляторы обычно помещают константу в одну ячейку памяти, обозначенную символом, а не распределяют по исполняемому файлу, как в макросе. Хотя это исключает преимущества скорости немедленного режима, есть преимущества в эффективности памяти, и отладчики могут работать с этими константами во время выполнения. Кроме того, хотя макросы могут быть переопределены случайно из-за конфликта файлов заголовков в C и C ++, конфликтующие константы обнаруживаются во время компиляции.
В зависимости от языка константы могут быть нетипизированными или типизированными. В C и C ++ макросы предоставляют первое, а const — второе:
#define PI 3.1415926535 const float pi2 = 3.1415926535;
в Ada есть универсальные числовые типы, которые при желании можно использовать:
pi: constant: = 3.1415926535; pi2: постоянное число с плавающей запятой: = 3,1415926535;
с нетипизированным вариантом, который неявно преобразуется в соответствующий тип при каждом использовании.
Константы с динамическими значениями
Помимо статических констант, описанных выше, многие процедурные языки, такие как Ada и C ++, расширяют концепция постоянства по отношению к глобальным переменным, которые создаются во время инициализации, локальным переменным, которые автоматически создаются во время выполнения в стеке или в регистрах, для динамически выделяемой памяти, доступ к которой осуществляется указателем, и для списков параметров в заголовках функций.
Константы с динамическими значениями не обозначают переменную как находящуюся в определенной области памяти, и значения не устанавливаются во время компиляции. В коде C ++, таком как
float func (const float ANYTHING)
выражение, которым инициализируется константа, не является константой. Использование постоянства здесь не обязательно для законности программы или семантической корректности, но имеет три преимущества:
- Читателю ясно, что объект не будет больше изменяться после установки
- Попытки изменить значение объекта (более поздние программисты, которые не полностью понимают логику программы) будут отклонены компилятором
- Компилятор может выполнять оптимизацию кода, зная, что значение объекта не изменится после создания.
Константы с динамическими значениями возникли как функция языка с АЛГОЛОМ 68. Исследования кода Ada и C ++ показали, что константы с динамическими значениями используются нечасто, обычно для 1% или менее объектов, хотя их можно было бы использовать гораздо больше, поскольку около 40–50% локальных неклассовых объектов фактически инвариантны. однажды созданный. С другой стороны, такие «неизменяемые переменные» обычно используются по умолчанию в функциональных языках, поскольку они отдают предпочтение стилям программирования без побочных эффектов (например, рекурсии) или делают большинство объявлений неизменяемыми по умолчанию. Некоторые языки, называемые чисто функциональными, даже полностью запрещают побочные эффекты.
Постоянство часто используется в объявлениях функций, как обещание, что когда объект передается по ссылке, вызываемая функция не изменит его. В зависимости от синтаксиса либо указатель, либо объект, на который указывают, могут быть постоянными, однако обычно желательно последнее. В C ++ и C, особенно в C ++ и C, дисциплина, обеспечивающая постоянство правильных структур данных во всей программе, называется const-correness.
Параметры постоянной функции
В C / C ++ можно объявить параметр функции или метода как постоянный. Это гарантия того, что этот параметр не может быть изменен после первого назначения (случайно). Если параметр является предопределенным (встроенным) типом, он вызывается значением и не может быть изменен. Если это пользовательский тип, переменная является адресом указателя, который также не может быть изменен.
Однако содержимое объекта можно изменять без ограничений. Объявление параметров как констант может быть способом показать, что это значение не должно изменяться, но программист должен иметь в виду, что проверки модификации объекта не могут выполняться компилятором.
Помимо этой функции, в C / C ++ также можно объявить функцию или метод как const . Это предотвращает изменение такими функциями или методами чего-либо, кроме локальных переменных.
В C # ключевое слово const существует, но не имеет такого же эффекта для параметров функции, как в C / C ++. Однако есть способ «побудить» компилятор выполнить проверку, хотя это немного сложно.
Чтобы получить тот же эффект, сначала определены два интерфейса.
открытый интерфейс IReadable > открытый интерфейс IWritable: IReadable > открытый класс AnObject: IWritable установить >>
Затем определенные методы выбирают правильный интерфейс с возможностями только для чтения или чтения / записи:
public void doSomething (IReadable aVariable) public void doSomethingElse (IWritable aVariable)
Объектно-ориентированные константы
Константная структура данных или объект упоминается как «неизменяемый » на объектно-ориентированном языке. Неизменяемость объекта дает некоторые преимущества при разработке программ. Например, его можно «скопировать», просто скопировав его указатель или ссылку, избегая трудоемкой операции копирования и сохраняя память.
Объектно-ориентированные языки, такие как C ++, еще больше расширяют постоянство. Отдельные члены структуры или класса могут быть сделаны константами, даже если класс не является. И наоборот, ключевое слово mutable позволяет изменять член класса, даже если объект был создан как const .
. Даже функции могут быть константными в C ++. Смысл здесь в том, что для объекта, созданного как const, может быть вызвана только функция const; константная функция не изменяет неизменяемые данные.
C # имеет квалификаторы const и только для чтения ; его const предназначена только для констант времени компиляции, тогда как readonly может использоваться в конструкторах и других приложениях времени выполнения.
Java
Java имеет квалификатор final , который предотвращает изменение ссылки и гарантирует, что она никогда не будет указывать на другой объект. Это не предотвращает внесение изменений в сам упомянутый объект. final в Java в основном эквивалентен указателю const в C ++. Он не предоставляет другие возможности const .
. В Java квалификатор final указывает, что затронутый элемент данных или переменная не может быть назначена, как показано ниже:
заключительный интервал я = 3; я = 4; // Ошибка! Невозможно изменить «конечный» объект
Он должен быть разрешен компиляторами, где инициализируется переменная с маркером final , и это должно быть выполнено только один раз, иначе класс не будет компилироваться. Ключевые слова Java final и C ++ const имеют одинаковое значение при применении с примитивными переменными.
const int i = 3; // Объявление C ++ i = 4; // Ошибка!
Что касается указателей, то ссылка final в Java означает нечто похожее на указатель const в C ++. В C ++ можно объявить «тип указателя const ».
Foo * const bar = mem_location; // Тип константного указателя
Здесь bar должен быть инициализирован во время объявления и не может быть изменен снова, но то, что он указывает, можно изменить. Т.е. * bar = значение допустимо. Он просто не может указывать на другое место. Заключительные ссылки в Java работают так же, за исключением того, что они могут быть объявлены неинициализированными.
final Foo i; // объявление Java
Примечание: Java не поддерживает указатели. Это связано с тем, что указатели (с ограничениями) являются способом доступа по умолчанию к объектам в Java, и Java не использует звездочки для их обозначения. Например, iв последнем примере является указателем и может использоваться для доступа к экземпляру.
Можно также объявить указатель на данные «только для чтения» в C ++.
const Foo * bar;
Здесь полоса может быть изменена так, чтобы указывать на что угодно и когда угодно; только указанное значение не может быть изменено с помощью указателя bar . В Java нет эквивалентного механизма. Таким образом, также нет методов const . В Java нельзя обеспечить постоянную корректность, хотя, используя интерфейсы и определяя интерфейс только для чтения для класса и передавая его, можно гарантировать, что объекты могут передаваться по системе таким образом, что они не могут быть изменены. Среда коллекций Java предоставляет способ создания неизменяемой оболочки для Collection с помощью Collections.unmodifiableCollection () и аналогичных методов.
Методы в Java могут быть объявлены « final », но это имеет совершенно не связанный с этим смысл — это означает, что метод не может быть переопределен в подклассах.
C #
В C # квалификатор readonly оказывает такое же влияние на элементы данных, как final в Java и const делает в C ++; модификатор const в C # имеет эффект, аналогичный (но типизированному и ограниченному по классу) эффекту #define в C ++. (Другой эффект запрета наследования final Java при применении к методам и классам вызывается в C # с помощью третьего ключевого слова, sealed .)
В отличие от C ++, C # не позволяет помечать методы и параметры как const . Однако можно также передавать подклассы, доступные только для чтения, и .NET Framework предоставляет некоторую поддержку для преобразования изменяемых коллекций в неизменяемые, которые могут передаваться как оболочки только для чтения.
По парадигме
Обработка констант значительно зависит от парадигмы программирования. Корректность констант — это проблема в императивных языках, таких как C ++, потому что по умолчанию привязки имен обычно создают переменные, которые могут варьироваться, как следует из названия, и, следовательно, если кто-то хочет пометить привязку как постоянный, это требует дополнительных указаний. В других парадигмах языков программирования возникают проблемы, связанные с обнаружением некоторых аналогов константной корректности.
В функциональном программировании данные обычно по умолчанию постоянные, а не переменные по умолчанию. Вместо присвоения значения переменной (пространство хранения с именем и потенциально значением переменной) создается привязка имени к значению, например, с помощью конструкции let во многих диалектах Лисп. В некоторых функциональных языках, особенно в многопарадигмальных, таких как Common Lisp, изменение данных является обычным делом, в то время как в других его избегают или считают исключительным; это случай Scheme (другой диалект Лиспа), который использует конструкцию set! для изменения данных, на что обращает внимание восклицательный знак ! . Такие языки по умолчанию достигают целей константной корректности, обращая внимание на модификацию, а не на постоянство.
В ряде объектно-ориентированных языков (OOL) существует концепция неизменяемого объекта, который особенно используется для базовых типов, таких как строки; примечательные примеры включают Java, JavaScript, Python и C #. Эти языки различаются в зависимости от того, могут ли определяемые пользователем типы быть помечены как неизменяемые, и могут позволять помечать определенные поля (атрибуты) объекта или типа как неизменяемые.
В некоторых многопарадигмальных языках, допускающих как объектно-ориентированные, так и функциональные стили, обе эти функции могут быть объединены. Например, в OCaml поля объекта неизменяемы по умолчанию и должны быть явно помечены ключевым словом mutable как изменяемые, тогда как в Scala привязки явно неизменяемы, определены с помощью val для «значения» или явно изменяемый, определенный с помощью var для «переменной».
Соглашения об именах
Соглашения об именах для констант различаются. Некоторые просто называют их, как любую другую переменную. Другие используют заглавные буквы и подчеркивания для констант аналогично их традиционному использованию для символьных макросов, например SOME_CONSTANT . В венгерской нотации префикс «k» обозначает константы, а также макросы и перечислимые типы.
Одно обязательное соглашение заключается в том, что в Ruby, любая переменная, начинающаяся с заглавной буквы, считается константой, включая имена классов.
См. Также
- Адресные константы для платформы IBM / 360 и Z / Architecture
Источник: alphapedia.ru
Лекции / Л№11.Константы .ИС / Константы
В процессе работы программы значение переменной может быть изменено. Например, в программе может встретиться строка, в которой написано следующее:
В = 33; // Строка 3
В этом случае при исполнении программы будет выполнено следующее:
- Константа 33 сообщает своё значение программе.
- Переменная В получает (новое) значение 33 от программы.
Легко заметить, что на некотором этапе выполнения программы переменная В получает значение 10, а в ходе дальнейших вычислений — значение 33. В результате этих событий название переменной В остаётся неизменным, а значение переменной изменяется. На рис. 10 показаны константы и переменные в тексте программы: Рис. 10. Константа и переменная в программе. 4.Декларация и инициализация констант. Константы — величины, которые не меняются на всем протяжении работы программы. Константы могут быть того же типа, что и переменные. Для объявления константы, используется следующий формат записи: const = Например, следующий фрагмент кода позволяет создать целочисленную константу с идентификатором theConst и значением 25. const int theConst = 25; В выражениях для иннициализации констант не допускается использовать переменные. Помимо явного объявления, константы могут фигурировать и в выражениях, как правило, для иннициализации или вычисления значений переменных. В этом случае, компилятор пытается автоматически определить тип данных, но программист может помочь компилятору, указав тип явно. 5.Задание констант с помощью директивы препроцессора. Константа может быть определена до главной функции main. В этом случае можно использовать директиву #define. Например, для определения константы можно перед фунцией main вставить строку #define PI 3.141592653589793 Если в тексте программы будет встречаться имя PI, оно автоматически будет заменяяться значением 3.141592653589793. С использованием этой константы программа для решения задачи 1.1 может быть переписана так. #include #include #define PI 3.141592653589793 int main() < float a,b,c, alf,bet,s; printf(«A=»); scanf(«%f», printf(«B=»); scanf(«%f», s=a*b/2; c=pow(a*a+b*b,0.5); alf=atan(a/b); bet=PI/2-alf; printf(«n A=%5.2f t B=%5.2f t C=%5.2f n»,a,b,c); printf(«nS=%5.2f t alf=%3.0f t bet=%3.0fn», s,alf*180/PI,bet*180/PI); >Мы совсем забыли про константы, а они играют отнюдь не последнюю роль. В языке Си константы принято писать полностью с заглавных букв: #define SIZE 15 Использование этих условий в разы облегчит вам понимание собственного кода, позволит другим программистам легко сориентироваться в вашем коде. Так же проблема придумывания имен функциям, классам и переменным отпадет само с собой. Причем если слабо знаете английский язык, то можете писать английскими буквами русские слова, что б было понятно, что будет делать тот или иной объект. И соответственно, чем больше размер вашей программы, тем актуальность стиля имен переменных в си возрастает. Не зря стиль программирования знает каждый профессиональный программист. 6. Использование констант Константы есть и в Си, но их никто не использует, ибо они были кривые. Числовые константы в C делают с помощью #define, и это неплохо работает, хотя и имеет свои минусы. Константы всех остальных типов в Cи используют редко. …А главное отличие — их теперь можно использовать! Например, можно написать так: const int N = 10; int A [N]; А раз константы можно использовать, отчего же этого не делать? Они многим лучше, чем #define: они имеют тип, а значит, позволяют найти ошибки в вашей программе; они могут быть не просто числом или строкой, но и какой-нибудь сложной структурой; их имена можно использовать при отладке (хотя с современными средствами это почти не актуально); они не имеют побочных эффектов и других классических проблем с макросами (отсылаю вас к предостережениям о директиве #define,написанных в любой хорошей книге по Си или Си++). Константы обязательно инициализировать, например: const int foo = 10; /* можно */ const int bar; /* нельзя */ Это логично, поскольку если мы не инициализируем её сразу, то вообще никогда не сможем ничего ей присвоить, поэтому в таком случае она окажется бесполезной. 7. Ввод-вывод констант //Ввод вывод констант. #include #include #define pi 3.141592 //Задание констант с помощью директивы препроцессора. int main() < const int i=10; //Декларация и инициализация констант. printf(«i= %i pi= %fn»,i,pi); printf(«konst= %in»,5); system(«pause»); return 0; >// i=10 i=10 //konst=5 Резюме. Декларация и инициализация констант. int i=7; Задание констант с помощью директивы препроцессора #define pi 3.141492 Ввод констант не предусмотрен. Вывод констант printf(“konst= %i i= %i pi= %fn”,5,i,pi); konst=5 i=7 pi=3.141592 8. Вопроы для самопроверки.
- Понятие константы.
- Свойства констант.
- Задание констант.
- Ввод вывод констант.
Источник: studfile.net
C Урок 13. Константы
Кроме переменных разного типа, а также массивов, для представления в программе существуют ещё и константы.
Константа — это значение, которое впоследствии в процессе программы не может быть изменено.
Константами мы уже, того не замечая, давно уже пользуемся в наших уроках. Мы использовали обычные целые и дробные числа, строки в кавычках, не используя при этом переменные. Это и были константы.
Константы, как и переменные, также могут иметь различный тип.
Целочисленный тип
Как и переменные, константы могут иметь, к примеру, целочисленный тип.
Этот тип используется в программе для представления в программе целых значений.
Причём, в отличие от переменных, константы могут по виду различаться не только в плане их максимальной величины, но ещё и по системе счисления.
Десятичные константы — последовательность цифр от 0 до 9, которая начинаются с цифры, отличной от нуля. Например, -54, 3, 15, 4321.
Восьмеричные — последовательность цифр от 0 до 7, которая всегда начинаются с цифры 0. Например, 0100, 03, 00, 04321.
Шестнадцатеричные — последовательность шестнадцатеричных цифр от 0 до F, которая в начале предваряется символами 0x. Причём, если у цифр будет буквенный вид (от A до F), то они могут выводиться как в нижнем, так и верхнем регистрах. Например, 0xFF, 0xabce, 0x01, 0x1A3C.
Также, как и переменные, целочисленные константы могут различаться и по размеру занимаемой памяти и по наличию или отсутствию знака, в связи с этим, они могут иметь определённый суффикс (постфикс).
Тип int — суффикса нет. Например 0, 50, 123456, 0xFFDDAABB.
А если нам нужно будет объявить беззнаковую константу, то мы уже добавляем суффикс u (U). Например, 0U, 1234u, 0xFFAACCBBU, 043210u.
Также мы можем выделить 8 байт под нашу константу, то есть объявить её типа long, добавив суффикс l (L).Например, 0L, 1234l, 0x10AADD00FFAACCBBL, 0123456L.
Можно и комбинировать ибо константа может иметь беззнаковый тип unsigned long. Например, 10UL, 412343ul, 0xFEAADD00FFAACCBBUL, 0123456UL.
Вещественный тип
Также константы могут быть и вещественного типа или с плавающей точкой.
Представляется такая константа в виде числа с плавающей точкой и по умолчанию, если не применять никаких суффиксов, ей назначается тип double (двойная точность). Состоит такая константа из целой части, точки, дробной части, символа экспоненты с самой экспонентой, которая может быть со знаком минус. Причём, эти пять видов представления не обязательно могут быть использованы все. Может отсутствовать экспонента, точка, дробная часть и даже целая часть.
Вот примеры констант с плавающей точкой (вещественного типа):
123.321, .012, 1.2345E-20, 321E15, .321E-9, 1234.
Если мы хотим использовать другой вещественный тип (float или long double), то для этого мы используем суффикс f (F) или l (L)
123.321f, .012L, 1.2345E-20l, 321E15L, .051E-9f, 1234567.L
Символьный тип
Константы могут также представлять и символы. Для этого они заключаются в символы апострофа
‘ ’, ‘0’, ‘n’, ‘t’, ‘n’, ‘r’, ‘s’, ‘3’, ‘A’, ‘Z’, ‘a’, ‘v’
Константы с символом обратного слэша () являются управляющими символами. Мы с ними также раньше встречались, например, переводя каретку и перенося строку.
Каждая символьная константа имеет код, например:
n — 0x0A — перевод строки,
a — 0x07 — звуковой сигнал,
r — 0x0D — возврат каретки,
Z — 0x5A — буква Z.
Строковый тип
Константы строкового типа имеют вид набора (последовательности) символов, заключённого в кавычки. Кавычки, соответственно в памяти не хранятся, они служат только для обозначения строкового типа.
В конце всего набора символов (строки) компилятор всегда добавляет код 0 (‘ ’), чтобы программе в процессе исполнения было легче определить окончание строки.
Вот примеры строковых констант
«Hello, World. »
«Hellorn»
Именованные константы
Если мы используем константы, не объявляя их заранее, а пишем прямо в выражениях в том виде, котором мы их только что рассмотрели, то это такие константы будут являться неименованными.
Также мы можем константы заранее объявить, тогда это уже будут именованные константы.
Такие константы мы можем объявить двумя способами.
Первый способ — директива препроцессора #define.
Используется она следующим образом
#define VAR_CONST1 15
После ключевого слова #define следует имя константы, а затем её значение. В результате этого впоследствии, если компилятор увидит где-то в коде данное имя, то он вместо него просто-напросто будет подставлять значение 15
printf( «Constant value is %d» , VAR_CONST1);
Вот ещё примеры таких констант
#define CONST0 0x00000000U
#define CONST1 0x00000001U
#define CONST2 0x00000002U
#define CONST4 0x00000004U
#define CONST8 0x00000008U
В качестве разделителей могут быть пробелы, табуляторы, также их серия, то есть не обязательно чтобы пробел и табулятор должен быть один.
Также такой вид объявления констант называют макросом, макроподстановкой или дефайновой заменой. В макросах помимо констант в значениях могут использоваться другие подстановки, мы с ними ещё встретимся впоследствии.
Второй способ объявления констант похож на объявление переменных, только перед типом мы ещё добавляем ключевое слово const
const int n = 0xFFFF ;
В дальнейшем мы данную константу с именем n можем использовать в нашем коде, например вот так
printf( «Constant value is %ld» , n);
Соответственно, изменить мы также константу n не можем по определению.
Такой способ объявления, как правило, больше нашел применение в языке C++, хотя в последнее время вполне применяется и в классическом C. Преимущество его по сравнению с дефайновой заменой то, что мы можем явно указать тип константы.
Думаю, на этом нам хватит теории, перейдём к практической части. Хоть мы и пользуемся константами практически в каждом уроке, там ещё есть над чем поразмыслить.
Как обычно, проект мы сделаем из проекта MYPROG12 прошлого занятия и имя ему присвоим MYPROG13.
Откроем файл main.c и в функции main(), как обычно, удалим весь код тела кроме возврата нуля, останется от него вот это
int main()
return 0 ; //Return an integer from a function
Удалим также все остальные (кроме main()) функции вместе с прототипами. Сначала поработаем с целыми типами.
Сначала неименованные константы.
Выведем обычное число типа int. Как мы знаем — это целочисленный тип для констант по умолчанию, поэтому суффиксов никаких мы не используем
Источник: narodstream.ru