Разное

Константы с: использование const для задания констант

Содержание

использование const для задания констант

 

Константы в С++ аналогичны константам в Си. Для представления константы в Си использовалась только директива препроцессора #define:

В С++ для представления константы рекомендуется использовать объявление переменной с начальным значением и ключевым словом const:

const тип ИмяПеременной = НачальноеЗначение;

const int n=10;

Область видимости константы такая же, как у обычной переменной. С помощью ключевого слова const можно объявить указатель на константу
 
const тип *ИмяПеременной;

 
 
 

const int *m; // m – указатель на константу типа int
const int n=3;
m = &n;

Еще одна возможность const состоит в создании постоянного указателя на величину указанного типа
тип *const ИмяПеременной = Значение;
 

 
 

int i;
int *const ptri=&i;

Использование const имеет несколько преимуществ по сравнению с #define.

  • При объявлении константы с использованием const явно указывается тип величины.
  • Константа, объявленная с использванием const, просто согласуется с производными типами, например, объявление массива:

    const int base_vals[5] = { 1000, 2000, 3500, 6000, 10000};

  • Идентификаторы const подчиняются тем же правилам, что и переменные. Можно создавать константы с различной областью видимости.

Перечислимый тип данных

С помощью ключевого слова enum можно объявить особый целочисленный тип с набором именованных целых констант, называемых перечислимыми константами:
 
enum тег {СписокИменованныхКонстант};

 
 

enum day {sun, mon, tue, wen, thu, fri, sat};
enum flag {false, true};

С помощью такого определения создается целочисленный тип day с названиями 7 дней недели, каждое из которых является целочисленной константой.

Перечислимые константы — идентификаторы, которые по умолчанию имеют следующие значения: 0, 1, 2, 3, 4, 5, 6. Первому присваивается значение 0, и каждому последующему – на 1 больше предыдущего.

Если не устраивают значения по умолчанию, то перечислимые константы могут быть инициализированы произвольными целыми константами или константными выражениями

 

enum number {a=54,b,c=60,d=c+5}; // b=55, d=65

Перечислимая константа может быть объявлена анонимно (без тега):

 
 

enum {off,on} signal;
signal=on;

Назад: Язык C++

Руководство по программированию на C#. Константы



  • Чтение занимает 2 мин


В этой статье

Константы — это постоянные значения, которые известны во время компиляции и не изменяются во время выполнения программы.Constants are immutable values which are known at compile time and do not change for the life of the program. Константы должны объявляться с модификатором const.Constants are declared with the const modifier. Только встроенные типы C# (за исключением System.Object) могут быть объявлены как const.Only the C# built-in types (excluding System.Object) may be declared as const. Пользовательские типы, включая классы, структуры и массивы, не могут объявляться как const.User-defined types, including classes, structs, and arrays, cannot be const. Модификатор readonly позволяет создать класс, структуру или массив, которые инициализируются один раз (например, в конструкторе), и впоследствии изменить их нельзя.Use the readonly modifier to create a class, struct, or array that is initialized one time at runtime (for example in a constructor) and thereafter cannot be changed.

C# не поддерживает методы, свойства или события const.C# does not support const methods, properties, or events.

Тип перечисления позволяет определять именованные константы для целочисленных встроенных типов (например int, uint, long и т. д.).The enum type enables you to define named constants for integral built-in types (for example int, uint, long, and so on). Дополнительные сведения см. в разделе Перечисление.For more information, see enum.

Константы должны инициализироваться сразу после объявления.Constants must be initialized as they are declared. Пример:For example:

class Calendar1
{
    public const int Months = 12;
}

В этом примере константа Months всегда имеет значение 12, и его не может изменить даже сам класс.In this example, the constant Months is always 12, and it cannot be changed even by the class itself. На самом деле в случае, если компилятор встречает идентификатор константы в исходном коде C# (например, Months), он подставляет значение литерала непосредственно в создаваемый им промежуточный язык (IL).In fact, when the compiler encounters a constant identifier in C# source code (for example, Months), it substitutes the literal value directly into the intermediate language (IL) code that it produces. Поскольку с константой в среде выполнения не связан адрес ни одной переменной, поля const не могут передаваться по ссылке и отображаться в выражении как левостороннее значение.Because there is no variable address associated with a constant at run time, const fields cannot be passed by reference and cannot appear as an l-value in an expression.

Примечание

Будьте внимательны, ссылаясь на постоянные значения, определенные в другом коде, например, в DLL.Use caution when you refer to constant values defined in other code such as DLLs. Если в новой версии DLL для константы определяется новое значение, старое значение литерала хранится в вашей программе вплоть до повторной компиляции для новой версии.If a new version of the DLL defines a new value for the constant, your program will still hold the old literal value until it is recompiled against the new version.

Несколько констант одного типа можно объявить одновременно, например:Multiple constants of the same type can be declared at the same time, for example:

class Calendar2
{
    public const int Months = 12, Weeks = 52, Days = 365;
}

Выражение, которое используется для инициализации константы, может ссылаться на другую константу, если не создает циклическую ссылку.The expression that is used to initialize a constant can refer to another constant if it does not create a circular reference. Пример:For example:

class Calendar3
{
    public const int Months = 12;
    public const int Weeks = 52;
    public const int Days = 365;

    public const double DaysPerWeek = (double) Days / (double) Weeks;
    public const double DaysPerMonth = (double) Days / (double) Months;
}

Константы могут иметь пометку public, private, protected, internal, protected internal или private protected.Constants can be marked as public, private, protected, internal, protected internal or private protected. Эти модификаторы доступа определяют, каким образом пользователи класса смогут получать доступ к константе.These access modifiers define how users of the class can access the constant. Дополнительные сведения см. в разделе Модификаторы доступа.For more information, see Access Modifiers.

Доступ к константам осуществляется так, как если бы они были статическими полями, поскольку значение константы одинаково для всех экземпляров типа.Constants are accessed as if they were static fields because the value of the constant is the same for all instances of the type. Для их объявления используйте ключевое слово static.You do not use the static keyword to declare them. Выражения, которые не относятся к классу, определяющему константу, должны включать имя класса, период и имя константы для доступа к этой константе.Expressions that are not in the class that defines the constant must use the class name, a period, and the name of the constant to access the constant. Пример:For example:

int birthstones = Calendar.Months;

Спецификация языка C#C# Language Specification

Дополнительные сведения см. в спецификации языка C#.For more information, see the C# Language Specification. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.The language specification is the definitive source for C# syntax and usage.

См. такжеSee also

Константы в C++

В работе рассказывается о использовании констант в языке программирования С++. Приведённая теория соответствует базовому уровню, и может быть полезна для тех, кто начинает изучать данный язык программирования.

Константы, как и переменные, представляют собой ячейки памяти, предназначенные для хранения данных. Однако, в отличие от последних, значение константы не может быть изменено в программе; поэтому создаваемая константа должна быть сразу инициализирована (т.е. константа инициализируется при объявлении).

В С++ предусмотрены два типа констант — литеральные и символьные. Литеральная константа — это значение, непосредственно задаваемое в программе; тип и значение такой константы определяется ее внешним видом. Различают следующие виды литеральных констант: числовые, символьные, строковые.

Числовые константы могут быть целыми и вещественными. Целые, в свою очередь, могут иметь десятичное (типа int), восьмеричное или шестнадцатеричное представление:

  • десятичные: -18, 0, 12, 345, …;
  • восьмеричные (начинаются с нуля): 00, 014, 045, 0777…;
  • шестнадцатеричные (начинаются с ): 0х0000, 0х1A27, 0х5FFF, FFF,…

По умолчанию целые десятичные константы имеют тип int.

Константам целого типа, используемым в программе, можно явно указать требуемый тип с помощью суффиксов L, l (long), U и u (unsigned). Например, константа 15L будет иметь тип long. Можно использовать суффиксы L и U одновременно, например, 24UL.

Константы вещественного типа имеют по умолчанию тип double. Примеры вещественных констант: -1.314, 3.98, 0.8765, … Также можно явно указать тип константы с помощью суффиксов F, f (float), L и l (long). Например, константа 1.57E+5L будет иметь тип long, а константа 3.22f — тип float.

Литеральные символьные константы задаются в апострофах, и их можно классифицировать на:

  • клавиатурные: ‘8’, ‘g’, ‘K’,…;
  • кодовые (используются для задания управляющих и разделительных символов и пишутся в паре с символом обратной косой черты (обратный «слеш»)): ‘\n’, ‘\a’, ‘\b’, ‘\t’, ‘\\’, ‘\’‘,…; назначение таких констант представлено ниже в таблице 1.5.
  • числовые кодовые (используются для задания ASCIIкодов символов): ‘\xhhh’ (h — шестнадцатеричная цифра), ‘\0ooo’ (o — восьмеричная цифра). Например, комбинация клавиш «Ctrl+Z» имеет код ASCII, равный 26; ему соответствует 032 в восьмеричной системе и 0x1A в шестнадцатеричной.

Таблица 1. Коды управляющих последовательностей

Код С++

Назначение

Десятичный код ASCII

Шестнадцатеричный код ASCII

\n

Новая строка

10

0xA

\t

Горизонтальная табуляция

9

0x9

\v

Вертикальная табуляция

11

0xB

\b

Возврат на одну позицию

8

0x8

\r

Возврат каретки

13

0xD

\a

Звук предупреждения

7

0x7

\\

Обратная косая черта, \

92

0x5C

\’

Одинарная кавычка, ‘

39

0x27

Двойная кавычка, «

34

0x22

Строковые константы представляют собой последовательности символов, заключенные в двойные кавычки: «Мир«, «Ошибка», «Укажите номер элемента», «Press any key…«, … Для хранения строковой константы требуется на 1 байт памяти больше, чем число символов между двойными кавычками в строковой константе. Этот дополнительный байт требуется для хранения кода-признака конца строки (000, или \0). Допускается использовать управляющие и разделительные символы внутри строковых констант, но в этом случае они указываются без апострофов: «\nНомер элемента», «Данные:\nвторая строка», и т.д.

Строковые константы типа wchar_t записываются с префиксом L, например: L»Year».

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

const int a = 10;
const float x  = 1.75;
const double y = 1.54E+12;
const char s = 'A';
const char Ch[] = "строка символов";
const wchar_t a[ ] = L"Year";

Как было сказано выше, в отличие от переменной, значение инициализированной константы изменить нельзя.

Приведем еще примеры с указателями. При этом используются 2 объекта: указатель, и то, на что он указывает. Причем один или оба объекта, в свою очередь, могут быть константами:

const char* p1 = "number";       // указатель на константу
char const* p2 = "number";       // указатель на константу
char *const p3 = "number";       // константный указатель
const char *const p4 = "number"; // константный указатель
// на константу

Первые две строки в этом примере аналогичны друг другу (тип и слово const можно менять местами). Отмечу также, что в данном примере *const является оператором объявления указателя, наряду с символом *.

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

char s[] = "number";     // массив символов
const char* p = s;       // указатель на константу
s[0] = 'z';              // изменяем один из символов (ошибки нет)
p[0] = 'z';              // будет выдано сообщение об ошибке:
                         // попытка изменить константу

Символьные (не литеральные) константы можно задавать также средствами препроцессора, на основе использования директивы #define:

#define DT 0.00017           // определяем числовую константу
#define ST "Press any key…"  // определяем строковую константу

После этого в тексте программы можно будет использовать имена DT и ST. Препроцессор перед компиляцией программы везде заменит имена DT и ST на соответствующие им значения 0.00017 и «Press any key…«.

Символьные (не литеральные) целочисленные константы можно задавать также с использованием типа enum.

Замечание. Ключевое слово const относится к одному из двух так называемых cv-спецификаторов. Второй спецификатор определяется ключевым словом volatile.

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

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

Если переменная не объявлена со спецификатором volatile, компилятор имеет право осуществлять описанную выше оптимизацию. Указание же спецификатора volatile говорит компилятору, что такая оптимизация не допускается.

Константы с плавающей точкой   . Язык Си

Константы с плавающей точкой   

Правила языка Си допускают несколько способов записи констант с плавающей точкой. Наиболее общая форма записи константы — это последовательность десятичных цифр со знаком, включающая в себя десятичную точку, затем символ е или Е и показатель степени по основанию 10 со знаком. Вот два примера:

-1.56Е+12    2.87е-3

     Знак + можно не писать. Разрешается также опускать либо десятичную точку, либо экспоненциальную часть, но не одновременно. Кроме того, можно не писать дробную или целую часть, но не обе сразу. Ниже приведено еще несколько правильно записанных констант с плавающей точкой:

3.14159

    .2

    4е16

    .8Е-5

    100.

Использовать пробелы при записи констант запрещается

1.56Е+ 12 — НЕПРАВИЛЬНО

     В процессе обработки константы с плавающей точкой рассматриваются в формате с удвоенной точностью. Предположим, например, что переменная some типа float получает свое значение в результате выполнения оператора

some = 4.0*2.0;

     В этом случае константы 4.0 и 2.0 размещаются в памяти как данные типа double, т. е. для каждой из них (обычно) отводится 64 бит. Их произведение (равное 8) вычисляется с помощью операции умножения, выполняемой с двойной точностью, и только после этого производится усечение результата до нормального размера, соответствующего типу float. Все это обеспечивает максимальную точность ваших вычислений.

Поделитесь на страничке

Следующая глава >

Константы в 1С 8.3 Предприятие


В связи с программами 1С вы наверняка слышали такое понятие, как «Константы». Константа – это данные, используемые для хранения значения в информационной базе, при этом имеющие одно и то же, неизменяемое значение, или значение, которое редко изменяется. Если значение изменено, в программе фиксируется дата его изменения и можно посмотреть, в каком периоде, какие значения были установлены. Подробнее, что такое константы и для чего они предназначены, посмотрим на примере бухгалтерской программы 1С.


Примером здесь могут стать данные нашей организации, различные даты регистрации (дата начала регистрации розничных продаж в ЕГАИС, дата версии программы и т.п.), установленные сроки (срок оплаты поставщикам, срок оплаты покупателям и т.п.), настройки и статусы программы (например, уплата НДС, применение упрощенной системы налогообложения и др.) и прочие настройки программы и справочников (установка типов цен, валюты), стоящие по умолчанию.


Ознакомиться с общим списком констант можно в разделе «Все функции». Если данный пункт меню недоступен, включить его можно в разделе «Сервис» — Параметры» — Отображать команду «Все функции».

Рис.1 Все функции
Рис.2 Все функции


В дереве метаданных программы мы видим раздел – «Константы».

Рис.3 Константы


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

Рис.4 Все функции


Если мы откроем нашу конфигурацию для автоматизации бухгалтерского учета на предприятии в режиме «Конфигуратор» и посмотрим структуру конфигурации, то там тоже увидим раздел «Константы» («Конфигурация» — «Открыть конфигурацию»).

Рис.5 Режим «Конфигуратор»


Например, откроем свойства константы «Учет зарплаты и кадров во внешней программе». Тип – «Булево». Это значит, пользователю при определении значения константы будет предоставлена возможность установить галочку.

Рис.6 Свойства константы «Учет зарплаты и кадров во внешней программе»


Кроме этого, значения могут быть числовые, формат, дата, строка, ссылки на выбор из различных справочников, какое-либо перечисление.

Рис.7 Виды значений

Константы в «1С:Бухгалтерия»


Рассмотрим, как выглядят некоторые константы при работе пользователя с программой «1С: Бухгалтерия 3.0». Например, константы задающие настройки учета организации будут находиться в разделе «Администрирование» — «Параметров учета».

Рис.8 Константы в «1С:Бухгалтерия»


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

Рис.9 Параметры учета


Перейдя в один из разделов (в нашем примере «Настройки зарплаты»), мы видим настройки этого раздела, которые выполняются установкой переключателя, галочки, а также ссылки на другие разделы, чтобы осуществить заполнение констант в 1С.

Рис.10 Раздел «Настройки зарплаты»


Перейдя в раздел «Функциональность», в пункте меню «Администрирование» мы можем также установить нужные нам значения по умолчанию.

Рис.11 Раздел «Функциональность»


Рассмотрим константы, устанавливаемые в карточке нашей организации. Обратите внимание, что у некоторых устанавливаемых по умолчанию значений есть кнопка «История», т.е. значения реквизитов хранятся, и мы в любой момент можем посмотреть, в какое время они были изменены и даты изменения.

Рис.12 Рассмотрим константы, устанавливаемые в карточке нашей организации


Например, значение реквизита «Подписи» – «Руководитель» действует с 31.12.2016 года. И при изменении этого реквизита (константы), эти данные будут отражены в истории.

Рис.13 Реквизит (константа)


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


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

Рис.14 Настройки налогов и отчетов
Рис.15 Настройки налогов и отчетов


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


Некоторые настройки программы можно выполнить, установив значения по умолчанию в разделе «Главное» — «Персональные настройки».

Рис.16 Персональные настройки


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

9. Константы языка СИ. Программирование

9. Константы языка СИ

Константы – это перечисление величин в программе. В языке СИ можно выделить четыре вида констант: целые константы, константы с плавающей запятой, символьные константы и строковые литералы.

Целая константа – это десятичное, восьмеричное или шестнадцатеричное число, представляющее целую величину в одной из известных форм: десятичной, восьмеричной или шестнадцатеричной. Десятичная константа включает в себя одну или несколько десятичных цифр, при этом первая цифра не должна быть нулем (иначе число будет воспринято как восьмеричное). Восьмеричная константа включает в себя обязательный нуль и одну или несколько восьмеричных цифр (среди цифр не должно быть восьмерки и девятки, так как данные цифры не входят в восьмеричную систему счисления). Шестнадцатеричная константа начинается с непременной последовательности 0х или 0Х и включает в себя одну или несколько шестнадцатеричных цифр, которые являются набором цифр шестнадцатеричной системы счисления: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Если необходимо образовать отрицательную целую константу, то применяется знак «-» перед записью константы (который называется унарным минусом). К примеру: –0x3A, –098, –36. Любой целой константе присваивается тип, который определяет преобразования, которые должны быть выполнены, если константа применяется в выражениях. Тип константы определяется так:

1) десятичные константы – это величины со знаком, и им присваивается тип int (целая) или long (длинная целая) по значению константы. Если константа меньше 32 768, то ее тип – int, иначе – long;

2) восьмеричным и шестнадцатеричным константам присваивается тип int, unsigned int (беззнаковая целая), long или unsigned long по величине константы.

Для того чтобы каждую целую константу определить типом long, в конце константы ставится буква «l» или «L». Пример: 2l, 9l, 138L, 0905L, OX2911L.

Константа с плавающей точкой – десятичное число, которое представлено в виде действительной величины с десятичной точкой или экспонентой. Формат записывается так: [цифры].[цифры] [Е|е [+|-] цифры].

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

Данный текст является ознакомительным фрагментом.

Читать книгу целиком

Поделитесь на страничке

Константы в языке 1С 8.3, 8.2 (в примерах)

Константы в языке 1С 8.3, 8.2 (в примерах)

Вступайте в мою группу помощник программиста.
В ней мы обсуждаем программирование в 1С.

2017-12-18T22:48:55+00:00 Документы Константы Перечисления РегистрыБухгалтерии
РегистрыНакопления РегистрыСведений Справочники

Скачать эти примеры в виде тестовой базы (как загрузить, как исследовать)

Полный синтаксис (нажмите, чтобы раскрыть)

Константы

Константы в системе 1С:Предприятие, как правило, служат для хранения информации, которая либо совсем не изменяется в процессе функционирования системы, либо изменяется достаточно редко. В константах хранится информация, характеризующая прикладную задачу в целом. Наиболее простой пример подобной информации — название организации, которое, как правило, не меняется.

В программных модулях для общих действий над заданными в конфигураторе константами (получение формы для управления константами, создание набора констант) служит объект КонстантыМенеджер. Для одновременного изменения значений определенной группы констант следует пользоваться объектом КонстантыНабор. Для чтения и записи значения определенной константы можно обращаться к объекту КонстантаМенеджер.<Имя константы>.

Оглавление (нажмите, чтобы раскрыть)

&НаСервере
Процедура ВыполнитьКодНаСервере()
 
    /// Как получить и изменить значение константы в 1с 8.3, 8.2    
 
    // менеджер значений создаётся и используется неявно
 
    Сообщить(Константы.ЛучшийКлиент.Получить());
 
    Константы.ЛучшийКлиент.Установить(
        Справочники.Клиенты.НайтиПоНаименованию("Марина")
    );
 
    /// Работа с константой через менеджер значений в 1с 8.3, 8.2
 
    // создаём и используем менеджер значений константы напрямую
    ЛюбимаяЕда = Константы.ЛюбимаяЕда.СоздатьМенеджерЗначения();
 
    // читаем значение
    ЛюбимаяЕда.Прочитать();    
    Сообщить(ЛюбимаяЕда.Значение);
 
    // меняем значение
    ЛюбимаяЕда.Значение = Справочники.Еда.НайтиПоНаименованию(
        "Крыжовник");
 
    // записываем значение
    ЛюбимаяЕда.Записать();
 
    /// Работа с константами через набор в 1с 8.3, 8.2
 
    // подходит для работы сразу с группой констант
 
    НазванияКонстант = "ЛюбимаяЕда, ЛучшийКлиент";
    НаборКонстант = Константы.СоздатьНабор(НазванияКонстант);
 
    // читаем набор констант
    НаборКонстант.Прочитать();
    Сообщить(НаборКонстант.ЛюбимаяЕда);
    Сообщить(НаборКонстант.ЛучшийКлиент);
 
    // меняем значения констант
    НаборКонстант.ЛюбимаяЕда = Справочники.Еда.НайтиПоНаименованию(
        "Чипсы");
    НаборКонстант.ЛучшийКлиент = Справочники.Клиенты.НайтиПоНаименованию(
        "Пётр");
 
    // записываем набор
    НаборКонстант.Записать();
 
    /// Как получить значения всех констант в 1с 8.3, 8.2
 
    Для Каждого Константа Из Константы Цикл
        Сообщить(Строка(Константа) + " = " + Константа.Получить());
    КонецЦикла;
 
КонецПроцедуры
 
/// Скачать и выполнить эти примеры на компьютере

Скачать эти примеры в виде тестовой базы (как загрузить, как исследовать)

Константы в языке 1С 8.3, 8.2 (в примерах)

Документы Константы Перечисления РегистрыБухгалтерии
РегистрыНакопления РегистрыСведений Справочники

С уважением, Владимир Милькин (преподаватель школы 1С программистов и разработчик обновлятора).

Как помочь сайту: расскажите (кнопки поделиться ниже) о нём своим друзьям и коллегам. Сделайте это один раз и вы внесете существенный вклад в развитие сайта. На сайте нет рекламы, но чем больше людей им пользуются, тем больше сил у меня для его поддержки.

Нажмите одну из кнопок, чтобы поделиться:

Константы

— Руководство по программированию на C #

  • 2 минуты на чтение

В этой статье

Константы — это неизменяемые значения, которые известны во время компиляции и не меняются в течение жизни программы. Константы объявляются с модификатором const. Только встроенные типы C # (кроме System.Object) можно объявить как const . Типы, определяемые пользователем, включая классы, структуры и массивы, не могут быть const . Используйте модификатор readonly для создания класса, структуры или массива, который инициализируется один раз во время выполнения (например, в конструкторе) и после этого не может быть изменен.

C # не поддерживает методы, свойства или события const .

Тип перечисления позволяет вам определять именованные константы для встроенных целочисленных типов (например, int , uint , long и т. Д.).Для получения дополнительной информации см. Enum.

Константы должны быть инициализированы так, как они объявлены. Например:

  класс Calendar1
{
    public const int Месяцев = 12;
}
  

В этом примере постоянная Месяцев всегда равна 12, и ее не может изменить даже сам класс. Фактически, когда компилятор встречает постоянный идентификатор в исходном коде C # (например, месяцев, ), он подставляет буквальное значение непосредственно в код промежуточного языка (IL), который он создает.Поскольку во время выполнения с константой не связан адрес переменной, поля const не могут передаваться по ссылке и не могут отображаться как l-значение в выражении.

Примечание

Будьте осторожны при обращении к постоянным значениям, определенным в другом коде, например в библиотеках DLL. Если новая версия библиотеки DLL определяет новое значение для константы, ваша программа все равно будет хранить старое буквальное значение, пока оно не будет перекомпилировано для новой версии.

Одновременно можно объявить несколько констант одного типа, например:

  класс Calendar2
{
    public const int Месяцы = 12, Недели = 52, Дни = 365;
}
  

Выражение, используемое для инициализации константы, может ссылаться на другую константу, если оно не создает циклическую ссылку.Например:

  класс Calendar3
{
    public const int Месяцев = 12;
    public const int Weeks = 52;
    public const int Days = 365;

    public const double DaysPerWeek = (двойные) дни / (двойные) недели;
    public const double DaysPerMonth = (двойные) дни / (двойные) месяцы;
}
  

Константы могут быть отмечены как общедоступные, частные, защищенные, внутренние, защищенные внутренние или частные защищенные. Эти модификаторы доступа определяют, как пользователи класса могут получить доступ к константе.Для получения дополнительной информации см. Модификаторы доступа.

Доступ к константам осуществляется как к статическим полям, потому что значение константы одинаково для всех экземпляров типа. Вы не используете ключевое слово static для их объявления. Выражения, не входящие в класс, определяющий константу, должны использовать имя класса, точку и имя константы для доступа к константе. Например:

  int Камни рождения = Calendar.Months;
  

Спецификация языка C #

Для получения дополнительной информации см. Спецификацию языка C #.Спецификация языка является исчерпывающим источником синтаксиса и использования C #.

См. Также

.

Как лучше всего реализовать константы в Java?

Переполнение стека

  1. Около
  2. Продукты

  3. Для команд
  1. Переполнение стека
    Общественные вопросы и ответы

  2. Переполнение стека для команд
    Где разработчики и технологи делятся частными знаниями с коллегами

  3. Вакансии
    Программирование и связанные с ним технические возможности карьерного роста

  4. Талант
    Нанимайте технических специалистов и создавайте свой бренд работодателя

  5. Реклама
    Обратитесь к разработчикам и технологам со всего мира

  6. О компании

Загрузка…

.Константы

— Учебники по C ++

Константы — это выражения с фиксированным значением.

Литералы

Литералы — наиболее очевидный вид констант. Они используются для выражения определенных значений в исходном коде программы. Мы уже использовали их ранее для присвоения конкретных значений переменным или для выражения сообщений, которые мы хотели бы распечатать нашими программами, например, когда мы написали:

5 в этом фрагменте кода было буквальной константой .

Литеральные константы можно разделить на Целые числа , Числа с плавающей запятой , Символы , Строки и Логические значения .

Целые числа

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

В дополнение к десятичным числам (те, которые все мы привыкли использовать каждый день), C ++ позволяет использовать восьмеричные числа ( base 8 ) и шестнадцатеричные числа ( base 16 ) в качестве буквальных констант. Если мы хотим выразить восьмеричное число, мы должны поставить перед ним 0 ( ноль символ). И чтобы выразить шестнадцатеричное число, мы должны поставить перед ним символы 0x ( ноль , x ). Например, все следующие буквальные константы эквивалентны друг другу:

  1 
2
3
  75  // десятичное 
0113  // восьмеричное 
0x4b  // шестнадцатеричный   

Все они представляют собой одно и то же число: 75 (семьдесят пять), выраженное десятичной, восьмеричной и шестнадцатеричной числами соответственно.

Считается, что буквальные константы, как и переменные, имеют определенный тип данных. По умолчанию целочисленные литералы имеют тип int . Однако мы можем заставить их быть беззнаковыми, добавив к нему символ и , или длинными, добавив l :

  1 
2
3
4
  75  // внутренний 
75u  // целое число без знака 
75л  // длинный 
75ul  // беззнаковое длинное   

В обоих случаях суффикс можно указать с помощью прописных или строчных букв.

Числа с плавающей запятой

Они выражают числа с десятичными знаками и / или показателями степени. Они могут включать десятичную точку, символ e (который выражает «на десять по высоте X», где X — целое число, следующее за символом e ), либо десятичную точку и e . символ:

  1 
2
3
4
  3,14159  // 3,14159 
6.02e23  // 6.-19 
3,0  // 3,0   

Это четыре действительных числа с десятичными знаками, выраженные в C ++. Первое число — это ПИ, второе — число Авогадро, третье — это электрический заряд электрона (чрезвычайно малое число) — все они аппроксимированы — и последнее — число три, выраженное в виде числа с плавающей точкой. числовой литерал.

Тип по умолчанию для литералов с плавающей запятой — double . Если вы явно хотите выразить числовой литерал с плавающей запятой или длинный двойной двойной , вы можете использовать суффиксы f или l соответственно:

  1 
2
  3.14159L  // длинный двойной 
6.02e23f  // поплавок   

Любые буквы, которые могут быть частью числовой константы с плавающей запятой ( e , f , l ), могут быть записаны с использованием строчных или прописных букв без какого-либо различия в их значениях.

Символьные и строковые литералы

Существуют также нечисловые константы, например:

  1 
2
3
4
   'z' 
  'п' 
  «Привет, мир» 
  "Как поживаете?"   

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

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

Только x будет относиться к переменной, идентификатор которой равен x , тогда как 'x' (заключенный в одинарные кавычки) будет относиться к символьной константе ‘x’ .

Символьные и строковые литералы имеют определенные особенности, такие как escape-коды. Это специальные символы, которые трудно или невозможно иначе выразить в исходном коде программы, например новая строка ( \ n ) или табуляция ( \ t ). Всем им предшествует обратная косая черта ( \ ). Вот список таких escape-кодов:

\ n новая строка
\ r возврат каретки
\ t tab
\ v вертикальная вкладка
\ b backspace
\ f подача формы (подача страницы)
\ a предупреждение (звуковой сигнал)
\ ' одинарная кавычка ()
\ " двойная кавычка (» )
\? вопросительный знак (? )
\ обратная косая черта ( \ )

Например:

  1 
2
3
4
   '\ n' 
  '\ t' 
  "Влево \ т вправо" 
  "один \ nдва \ nтри"   

Кроме того, вы можете выразить любой символ его числовым кодом ASCII, написав символ обратной косой черты ( \ ), за которым следует код ASCII, выраженный как восьмеричное ( base-8, ) или шестнадцатеричное ( base-16 ) число.В первом случае (восьмеричном) цифры должны следовать сразу за обратной косой чертой (например, \ 23 или \ 40 ), во втором случае (шестнадцатеричный) перед самими цифрами должен быть написан символ x (для например \ x20 или \ x4A ).

Строковые литералы можно расширить до более чем одной строки кода, поставив знак обратной косой черты ( \ ) в конце каждой незавершенной строки.

  1 
2
   "строка, выраженная в \
две строки »  

Вы также можете объединить несколько строковых констант, разделив их одним или несколькими пробелами, табуляторами, новой строкой или любым другим допустимым пробелом:

   
   "это формирует"   "единую"   "строку"   "символов"   

Наконец, если мы хотим, чтобы строковый литерал явно состоял из широких символов (тип wchar_t ), вместо узких символов (тип char ), мы можем поставить перед константой префикс L :

   
  L  «Это строка широких символов»   

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

Логические литералы

Есть только два допустимых логических значения: true и false . Они могут быть выражены в C ++ как значения типа bool с использованием логических литералов true и false .

Определенные константы (#define)

Вы можете определить свои собственные имена для констант, которые вы используете очень часто, не прибегая к переменным, потребляющим память, просто с помощью директивы препроцессора #define . Его формат:

# определить значение идентификатора

Например:

  1 
2
   #define PI 3.14159 
  #define NEWLINE '\ n'   

Это определяет две новые константы: PI и NEWLINE . После того, как они определены, вы можете использовать их в остальной части кода, как если бы они были любой другой регулярной константой, например:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   // определенные константы: вычислить длину окружности 

  #include  
  с использованием пространства имен    std;

  # определить PI 3.14159 
  #define NEWLINE '\ n' 

  int  main ()
{
    двойной  r = 5,0;  // радиус 
    двойной  круг;

  круг = 2 * пи * р;
  cout << круг;
  cout << NEWLINE;

    возврат  0;
}  
  31.4159  

Фактически, единственное, что препроцессор компилятора делает, когда встречает директивы #define , — это буквально заменять любое вхождение их идентификатора (в предыдущем примере это были PI и NEWLINE ) на код, к которому они были определены ( 3.14159 и '\ n' соответственно).

Директива #define — это не инструкция C ++, а директива для препроцессора; поэтому он принимает всю строку как директиву и не требует точки с запятой (; ) в конце. Если вы добавите в конце символ точки с запятой (; ), он также будет добавлен во все вхождения идентификатора в теле программы, которую заменяет препроцессор.

Объявленные константы (const)

С префиксом const вы можете объявлять константы определенного типа так же, как и с переменной:

  1 
2
   const   int  pathwidth = 100;
  const   char  tabulator =  '\ t' ;  

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

.

Постоянно — Символьные константы в Python — Постоянно 15.1.0 + 17.g39887b6. Грязная документация

Обзор

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

В этом документе объясняется, как использовать эти API и в каких обстоятельствах они могут быть полезны.

Имена констант

Константы, которые не имеют значения, кроме их имени и идентичности, могут быть определены путем постоянного подкласса . Имена .
Рассмотрим этот пример, в котором определены некоторые константы метода HTTP-запроса.

 из постоянно импортируемых NamedConstant, Names
МЕТОД класса (Имена):
    "" "
    Константы, представляющие различные методы HTTP-запроса.
    "" "
    GET = NamedConstant ()
    PUT = NamedConstant ()
    POST = NamedConstant ()
    УДАЛИТЬ = NamedConstant ()
 

Поддерживаются только прямые подклассы Имен (т.е.е., вы не можете создать подкласс METHOD для добавления новых констант в коллекцию).

Учитывая это определение, константы можно искать по имени, используя доступ к атрибутам в объекте МЕТОД :

 >>> METHOD.GET
<МЕТОД = ПОЛУЧИТЬ>
>>> METHOD.PUT
<МЕТОД = ВЫЛОЖИТЬ>
 

Если необходимо найти константы из строки (например, на основе какого-либо пользовательского ввода), безопасный способ сделать это — использовать lookupByName :

 >>> МЕТОД.lookupByName ('ПОЛУЧИТЬ')
<МЕТОД = ПОЛУЧИТЬ>
>>> МЕТОД.lookupByName ('__ doc__')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
  Файл "постоянно / _constants.py", строка 145, в lookupByName
    поднять ValueError (имя)
ValueError: __doc__
 

Как показано, это безопасно, потому что любое имя, не связанное с константой (даже те специальные имена, инициализированные самим Python), приведет к возникновению ValueError , а не какого-либо другого объекта, не предназначенного для использования таким образом, как используются константы.

Константы также можно перечислить с помощью метода iterconstants :

 >>> список (МЕТОД.iterconstants ())
[, , , ]
 

Константы можно сравнить на равенство или идентичность:

 >>> METHOD.GET есть METHOD.GET
Правда
>>> METHOD.GET == METHOD.GET
Правда
>>> METHOD.GET есть METHOD.PUT
Ложь
>>> METHOD.GET == METHOD.PUT
Ложь
 

Упорядоченные сравнения (и, следовательно, сортировка) также работают.Порядок определяется таким же, как порядок создания экземпляров констант:

 >>> из постоянно импортируемых NamedConstant, Names
>>> Буквы класса (Имена):
... a = NamedConstant ()
... b = NamedConstant ()
... c = NamedConstant ()
...
>>> Letters.a >> Letters.a> Letters.b
Ложь
>>> отсортировано ([Letters.b, Letters.a, Letters.c])
[, , ]
 

Подкласс Names может определять методы класса для реализации настраиваемых функций.Рассмотрим это определение МЕТОД :

 из постоянно импортируемых NamedConstant, Names
МЕТОД класса (Имена):
    "" "
    Константы, представляющие различные методы HTTP-запроса.
    "" "
    GET = NamedConstant ()
    PUT = NamedConstant ()
    POST = NamedConstant ()
    УДАЛИТЬ = NamedConstant ()

    @classmethod
    def isIdempotent (cls, метод):
        "" "
        Верните True, если данный метод не имеет побочных эффектов, иначе False.
        "" "
        метод возврата - cls.GET
 

Эта функциональность может использоваться, поскольку используются любые методы класса:

 >>> МЕТОД.isIdempotent (METHOD.GET)
Правда
>>> METHOD.isIdempotent (METHOD.POST)
Ложь
 

Константы со значениями

Константы с определенным ассоциированным значением постоянно поддерживаются базовым классом . Значения .
Рассмотрим этот пример, в котором определены некоторые константы кода состояния HTTP.

 из постоянно импортируемых ValueConstant, Values
class STATUS (значения):
    "" "
    Константы, представляющие различные коды состояния HTTP.
    "" "
    OK = ValueConstant ("200")
    НАЙДЕНО = ValueConstant ("302")
    NOT_FOUND = ValueConstant ("404")
 

Как и в случае с именами , константы доступны как атрибуты объекта класса:

 >>> СТАТУС.в порядке
<СТАТУС = ОК>
>>> СТАТУС НАЙДЕН
<СТАТУС = НАЙДЕН>
 

Кроме того, к значениям констант можно получить доступ с помощью атрибута value одного из следующих объектов:

 >>> STATUS.OK.value
'200'
 

Как и в случае с именами , константы можно искать по имени:

 >>> STATUS.lookupByName ('NOT_FOUND')

 

Константы в подклассе Values ​​ также можно найти по значению:

 >>> СТАТУС.lookupByValue ('404')

>>> STATUS.lookupByValue ('500')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в  

.

Добавить комментарий

Ваш адрес email не будет опубликован.