Константы

Для хранения значений, которые в течении работы программы не должны меняться, в Rust предназначены константы. Константы определяются с помощью ключевого слова const в следующем формате:

const название_константы : тип_данных = значение;

Определим константу и выведем ее значение на консоль:

fn main(){
	const PI : f32 = 3.14;
    println!("PI = {}", PI);
}

Здесь определена константа PI, которая имеет значение 3.14. Согласно условностям названия констант указываются в верхнем регистре.

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

fn main(){
	const PI : f32 = 3.14;
    println!("PI = {}", PI);
	PI  = 3.141;	// ошибка!
    println!("PI = {}", PI);
}

Может возникнуть вопрос, в чем отличие констант от обычных переменных, значение которых по умолчанию тоже нельзя изменять.

Прежде всего, отличия констант и переменных в синтаксисе: для определения констант используется ключевое слово const, и при этом для констант обязательно надо указать тип данных. А переменные определяются с помощью ключевого слова let, а их тип можно не указывать, если при объявлении переменной ей тут же присваивается значение. Кроме того, переменные можно определить с ключевым словом mut и сделать их изменяемыми, что нельзя сделать с константами.

let mut age = 36;
const PI : f32 = 3.14;

Другое отличие состоит в том, что переменную можно вначале объявить, а потом присвоить ей значение (по крайней мере до ее использования):

let age: u32;
age	= 36;

А константе надо присвоить значение сразу же при ее объявлении:

const PI : f32; 	// Ошибка!! Константе должно быть присвоено значение!
PI = 3.14;

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

fn main(){

	let number : i32 = sum(1, 2);
	println!("number = {}", number);
	
	const NUM : i32 = sum(1, 2); // ! Ошибка
	println!("NUM = {}", NUM);	
}
fn sum(a: i32, b: i32) -> i32 { a + b }

Другой пример динамической установки данных, который не сработает с константами:

fn main(){
	let a = 10;
	let b = 5;
	
	let number : i32 = if true { a + b } else {a - b};
	println!("number = {}", number);
	
	const NUM : i32 = if true { a + b } else {a - b}; // ! Ошибка
	println!("NUM = {}", NUM);	
}

В данном случае константа NUM получает значение из конструкции if..else. Но если в случае с переменной number проблем не возникнет. То при определения значения константы компилятор возвестит нас об ошибке. Хотя если вместо вычислений из конструкции if..else передавались бы константные значения, то ошибки бы не возникло:

fn main(){
	const NUM : i32 = if true { 3 } else { 5 };
	println!("NUM = {}", NUM);	// 3	
}

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

const NUM : i32 = 225;
let number : i32 = 226;	// !Ошибка

fn main(){

	println!("number = {}", number);
	println!("NUM = {}", NUM);	
}

В данном случае в глобальной области видимости (вне функции main) определены константа NUM и переменная number. Однако если константу мы можем определить в глобальной области видимости, то переменную НЕ можем. Поэтому при компиляции данной программы возникнет ошибка.