Вводный курс. язык программирования java

Содержание:

Примеры

package Edureka;

import java.io.*; 
import java.util.*; 

public class javaIntegerExamples{    
	    public static void main(String args[])  
	    { 
	    		 int value = 161;
	    		 // Get the binary equivalent
	    		 System.out.println("Binary equivalent:"+Integer.toBinaryString(value));
	    		 System.out.println("Bit Count:"+Integer.bitCount(value));

	    		 //example for byteValue()
	    		 int Value1=123;
	    		 Integer a = new Integer(Value1);
	    			System.out.println("Byte Value is "+a.byteValue());
	    			
	    		//compare two integer values
	    			System.out.println(Integer.compare(20, 20));
	    			System.out.println(Integer.compare(20, 19));
	    			System.out.println(Integer.compare(20, 22));
	    			
	    		//compare two integers
	    			Integer value2 = new Integer(50);
	    			System.out.println(value2.compareTo(50)); 
	    			System.out.println(value2.compareTo(49));
	    			System.out.println(value2.compareTo(51));
	    			
	    		//decode the string
	    			System.out.println(Integer.decode("0124")); //base8
	    			System.out.println(Integer.decode("0x124")); //base16
	    		 }
	    		 
	    }

Присваивания литералов

Язык программирования java: чем он хорош и сколько зарабатывают java-разработчики

Вы можете объявить и инициализировать переменную, назначив ей десятичный литерал, шестнадцатеричный литерал, Восьмеричный литерал или (начиная с Visual Basic 2017) двоичный литерал. Если целочисленный литерал выходит за пределы диапазона (то есть, если он меньше Int32.MinValue или больше Int32.MaxValue), возникает ошибка компиляции.

В следующем примере целые числа, равные 90 946 и представленные в виде десятичного, шестнадцатеричного и двоичного литерала, назначаются значениям .

Примечание

Используйте префикс или , чтобы обозначить шестнадцатеричный литерал, префикс или обозначить двоичный литерал, а также префикс или обозначить Восьмеричный литерал. У десятичных литералов префиксов нет.

Начиная с Visual Basic 2017, можно также использовать символ подчеркивания () в качестве разделителя цифр, чтобы улучшить удобочитаемость, как показано в следующем примере.

Начиная с Visual Basic 15,5, можно также использовать символ подчеркивания () в качестве начального разделителя между префиксом и шестнадцатеричными, двоичными или восьмеричными цифрами. Пример:

Чтобы использовать символ подчеркивания в качестве начального разделителя, нужно добавить в файл проекта Visual Basic (*.vbproj) следующий элемент:

Для получения дополнительной информации см.

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

Ссылочный тип данных. (Reference)

С чего начать изучение язык программирования java

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

Ссылочные типы в языке Java включают:

- Массивы
- Классы
- Интерфейсы
- Перечисления

Свойства ссылочного типа данных:

Различие примитивных и ссылочных типов данных

Возьмем примитивный тип int и рассмотрим следующий код:

int a=5;    // объявляем первую переменную и инициализируем ее
int b=a;    // объявляем вторую переменную, далее присваиваем b=a.
            //В этой операции выполняется копирование значения ячейки а в ячейку b
a=3;        // меняем значение первой переменной
// выводим значение переменной a
System.out.println(“a= “ + a);         // будетвыведено  a= 3
// выводим значение переменной b
System.out.println(“b= “ + b);         // будет выведено b= 5

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

Выполним операцию присвоения (копирования) для ссылочных переменных. Для этого напишем простой класс Point -точка на плоскости, имеющая координаты x и y.

public static class Point{
    public   int x; //координататочки x
    public   inty; //координата тоски y
//конструктор
Point(int X, int Y) {
    x=X;
    y=Y;
  }
}

Создадим несколько объектов класса Point и выполним операцию присвоения.

//cоздаем объект – первую точку
//при выполнении данной операции будет
//создана переменная объектного типа p1,
//которая будет содержать адрес объекта 
Point p1 = new Point(1,1);
//создаем переменную p2 и выполняем 
//операцию присваивания
Point p2=p1;
//меняем координату x первого объекта
p1.x=7;
//выводим координаты первого и второго объекта
System.out.println("p1.x="+ p1.x);
System.out.println("p1.y="+ p1.y);
System.out.println("p2.x="+ p2.x);
System.out.println("p3.y="+ p2.y);
System.out.println("---------");
//создаем переменную p3 и выполняем
Point p3 = null;
//создаем третий объект
p3= new Point(3,3);
//выполняем операцию присваивания
//теперь все переменные указывают на 
//третий объект
p2=p3;
p1=p3;
System.out.println("p3.x="+ p3.x);
System.out.println("p3.y="+ p3.y);
//выводим коорлинаты
System.out.println("---------");
System.out.println("p1.x="+ p1.x);
System.out.println("p1.y="+ p1.y);
System.out.println("p2.x="+ p2.x);
System.out.println("p3.y="+ p2.y);
System.out.println("---------");

буудет выведено:

p1.x=7p1.y=1p2.x=7p3.y=1———p3.x=3p3.y=3———p1.x=3p1.y=3p2.x=3p3.y=3———

Из данного примера следует, что при выполнении операции присвоения применительно к ссылочным переменным копируются адреса, а не сами данные. В данном примере мы получили, что все объектные переменные ссылаются на третий объект. Первый объект остался существовать, но на него никто не ссылается. Более того, адрес первого объекта нигде не сохранился, и поэтому это потерянный объект, другими словами «мусор», который только занимает память.

Союзы

Магия виртуализации: вводный курс в proxmox ve

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

union {
	int i;
	float f;
	struct {
		unsigned int u;
		double d;
	} s;
} u;

Общий размер — это размер, который является суммой размеров и, поскольку он больше, чем оба и . При назначении чему-либо некоторые части могут быть сохранены, если они меньше, чем .

Чтение из члена объединения — это не то же самое, что приведение, поскольку значение члена не конвертируется, а просто читается.

Биты целочисленных значений

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

Листинг 3

var green uint8 = 3
fmt.Printf(«%08b\n», green) // Выводит: 00000011
green++
fmt.Printf(«%08b\n», green) // Выводит: 00000100

1
2
3
4

vargreen uint8=3

fmt.Printf(«%08b\n»,green)// Выводит: 00000011

green++

fmt.Printf(«%08b\n»,green)// Выводит: 00000100

Задание для проверки:

Используйте Go Playground, чтобы поэкспериментировать с целочисленным переполнением:

Листинг 2 (один из примеров урока) увеличивает значения и на 1. Что произойдет при добавлении более крупного числа к каждой переменной?
Рассмотрите иной вариант развития событий. Что случится при уменьшении значения , когда то равно 0 или уменьшения , когда то равно -128?
Целочисленное переполнение также касается 16, 32 и 64-битных целых чисел. Что произойдет при объявлении , присвоенного к максимальному значению 65535, а затем уменьшенному на 1?

Пакет определяет как 65535 и min/max константы для каждого независимого от архитектуры целочисленного типа. Помните, что int и uint могут быть как 32, так и 64-битными, зависит от компьютера.

В примере выше (Листинг 3) увеличение приводит к перемещению 1, что оставляет нули справа. Результат является бинарным, что равняется 4 в десятичной системе. Это показано на схеме ниже.

Перемещение 1 в бинарном дополнении

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

Куда перемещаться дальше?

Листинг 4

var blue uint8 = 255
fmt.Printf(«%08b\n», blue) // Выводит: 11111111
blue++
fmt.Printf(«%08b\n», blue) // Выводит: 00000000

1
2
3
4

varblue uint8=255

fmt.Printf(«%08b\n»,blue)// Выводит: 11111111

blue++

fmt.Printf(«%08b\n»,blue)// Выводит: 00000000

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

Вопрос для проверки:

Какой специальный символ нужно использовать, чтобы увидеть биты?

Целочисленные типы фиксированного размера

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

Название	Тип	Диапазон значений
int8_t	1 байт signed	от -128 до 127
uint8_t	1 байт unsigned	от 0 до 255
int16_t	2 байта signed	от -32 768 до 32 767
uint16_t	2 байта unsigned	от 0 до 65 535
int32_t	4 байта signed	от -2 147 483 648 до 2 147 483 647
uint32_t	4 байта unsigned	от 0 до 4 294 967 295
int64_t	8 байт signed	от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
uint64_t	8 байт unsigned	от 0 до 18 446 744 073 709 551 615

Начиная с C++11 доступ к этим типам осуществляется через подключение заголовочного файла cstdint (находятся эти типы данных в пространстве имен std). Рассмотрим пример на практике:

#include <iostream>
#include <cstdint>

int main()
{
std::int16_t i(5); // прямая инициализация
std::cout << i << std::endl;
return 0;
}

1
2
3
4
5
6
7
8
9

#include <iostream>
#include <cstdint>

intmain()

{

std::int16_ti(5);// прямая инициализация

std::cout<<i<<std::endl;

return;

}

Поскольку целочисленные типы фиксированного размера были добавлены еще до C++11, то некоторые старые компиляторы предоставляют доступ к ним через подключение заголовочного файла stdint.h.

Если ваш компилятор не поддерживает cstdint или stdint.h, то вы можете скачать кроссплатформенный заголовочный файл pstdint.h. Просто подключите его к вашему проекту, и он самостоятельно определит целочисленные типы фиксированного размера для вашей системы/архитектуры.

Общие понятия

Типом данных в программировании называют совокупность двух множеств: множество значений и множество операций, которые можно применять к ним. Например, к типу данных целых неотрицательных чисел, состоящего из конечного множества натуральных чисел, можно применить операции сложения (+), умножения (*), целочисленного деления (/), нахождения остатка (%) и вычитания (−).

Язык программирования, как правило, имеет набор примитивных типов данных — типы, предоставляемые языком программирования как базовая встроенная единица. В C++ такие типы создатель языка называет фундаментальными типами. Фундаментальными типами в C++ считаются:

логический ();
символьный (напр., );
целый (напр., );
с плавающей точкой (напр., );
перечисления (определяется программистом);
.

Поверх перечисленных строятся следующие типы:

указательные (напр., );
массивы (напр., );
ссылочные (напр., );
другие структуры.

Перейдём к понятию литерала (напр., 1, 2.4F, 25e-4, ‘a’ и др.): литерал — запись в исходном коде программы, представляющаясобой фиксированное значение. Другими словами, литерал — это просто отображение объекта (значение) какого-либо типа в коде программы. В C++ есть возможность записи целочисленных значений, значений с плавающей точкой, символьных, булевых, строковых.

Литерал целого типа можно записать в:

10-й системе счисления. Например, ;
8-й системе счисления в формате 0 + число. Например, ;
16-й системе счисления в формате 0x + число. Например, .

24, 030, 0x18 — это всё записи одного и того же числа в разных системах счисления.
Для записи чисел с плавающей точкой используют запись через точку: 0.1, .5, 4. — либо в
экспоненциальной записи — 25e-100. Пробелов в такой записи быть не должно.

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

const int example = 3;
// здесь const — спецификатор
// int — базовый тип
// example — имя переменной
// = 3 — инициализатор.

Имя переменной является последовательностью символов из букв латинского алфавита (строчных и прописных), цифр и/или знака подчёркивания, однако первый символ цифрой быть не может. Имя переменной следует выбирать таким, чтобы всегда было легко догадаться о том, что она хранит, например, «monthPayment». В конспекте и на практиках мы будем использовать для правил записи переменных нотацию CamelCase. Имя переменной не может совпадать с зарезервированными в языке словами, примеры таких слов: if, while, function, goto, switch и др.

Декларатор кроме имени переменной может содержать дополнительные символы:

— указатель; перед именем;
— константный указатель; перед именем;
— ссылка; перед именем;
— массив; после имени;
— функция; после имени.

Инициализатор позволяет определить для переменной её значение сразу после объявления. Инициализатор начинается с литерала равенства (=) и далее происходит процесс задания значения переменной. Вообще говоря, знак равенства в C++ обозначает операцию присваивания; с её помощью можно задавать и изменять значение переменной. Для разных типов он может быть разным.

Спецификатор задаёт дополнительные атрибуты, отличные от типа. Приведённый в примере спецификатор const позволяет запретить последующее изменение значение переменной. Такие неизменяемые переменные называют константными или константой.

Объявить константу без инициализации не получится по логичным причинам:

const int EMPTY_CONST; // ошибка, не инициализована константная переменная
const int EXAMPLE = 2; // константа со значением 2
EXAMPLE = 3; // ошибка, попытка присвоить значение константной переменной

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

Другие решения

они одинаковы, с двумя различными синтаксисами инициализации (C-подобный первому, стиль конструктора второй); в принципе они немного отличаются при работе с классами (первый подразумевает — потенциально исключенный — вызов конструктора копирования, второй — нет), но для с они фактически одинаковы.

В первом не инициализируется (оно будет иметь любое значение в той области памяти); во втором случае инициализируется до 0.

Но самое главное, это два совершенно разных зверя по отношению к первым. Вы не объявляете автоматические переменные типа , но указатели в , которые указывают на два динамически распределяется s.

Разница глубокая: с память управляется автоматически (она имеет продолжительность автоматического хранения), и переменная уничтожается, когда выходит из области видимости; с Вы выделяете память из freestore (так называемой кучи), которая не имеет метода автоматического освобождения — вы должны освободить ее явно (с помощью хотя в современном C ++ интеллектуальные указатели обычно используются для автоматического управления временем жизни динамических объектов).

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

Для «обычных», местных переменные, которые должны «умереть» с текущей областью действия обычно это не очень хорошая идея.

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

в C и ранних C ++ вы могли использовать только int i = 0;

шаблон такой же, как конструктор для общего типа

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

подразумевает выделение кучи памяти (которая может просочиться), поэтому нет, вы не хотите делать это все время.

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

Кто-то может присоединиться и ссылаться на спецификацию языка для более точного ответа.

-1

Числовые типы данных

Тип данных	Объем памяти	Диапазон	Описание
TINYINT (M)	1 байт	от -128 до 127 или от 0 до 255	Целое число. Может быть объявлено положительным с помощью ключевого слова UNSIGNED, тогда элементам столбца нельзя будет присвоить отрицательное значение. Необязательный параметр М — количество отводимых под число символов. Необязательный атрибут ZEROFILL позволяет свободные позиции по умолчанию заполнить нулями.Примеры: TINYINT — хранит любое число в диапазоне от -128 до 127. TINYINT UNSIGNED — хранит любое число в диапазоне от 0 до 255. TINYINT (2) — предполагается, что значения будут двузначными, но по факту будет хранить и трехзначные. TINYINT (3) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 002.
SMALLINT (M)	2 байта	от -32768 до 32767 или от 0 до 65535	Аналогично предыдущему, но с большим диапазоном.Примеры: SMALLINT — хранит любое число в диапазоне от -32768 до 32767. SMALLINT UNSIGNED — хранит любое число в диапазоне от 0 до 65535. SMALLINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить и пятизначные. SMALLINT (4) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 0002.
MEDIUMINT (M)	3 байта	от -8388608 до 8388608 или от 0 до 16777215	Аналогично предыдущему, но с большим диапазоном.Примеры: MEDIUMINT — хранит любое число в диапазоне от -8388608 до 8388608. MEDIUMINT UNSIGNED — хранит любое число в диапазоне от 0 до 16777215. MEDIUMINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить и семизначные. MEDIUMINT (5) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 00002.
INT (M) или INTEGER (M)	4 байта	от -2147683648 до 2147683648 или от 0 до 4294967295	Аналогично предыдущему, но с большим диапазоном.Примеры: INT — хранит любое число в диапазоне от -2147683648 до 2147683648. INT UNSIGNED — хранит любое число в диапазоне от 0 до 4294967295. INT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить максимально возможные. INT (5) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 00002.
BIGINT (M)	8 байта	от -263 до 263-1 или от 0 до 264	Аналогично предыдущему, но с большим диапазоном.Примеры: BIGINT — хранит любое число в диапазоне от -263 до 263-1. BIGINT UNSIGNED — хранит любое число в диапазоне от 0 до 264. BIGINT (4) — предполагается, что значения будут четырехзначные, но по факту будет хранить максимально возможные. BIGINT (7) ZEROFILL — свободные позиции слева заполнит нулями. Например, величина 2 будет отображаться, как 0000002.
BOOL или BOOLEAN	1 байт	либо 0, либо 1	Булево значение. 0 — ложь (false), 1 — истина (true).
DECIMAL (M,D) или DEC (M,D) или NUMERIC (M,D)	M + 2 байта	зависят от параметров M и D	Используются для величин повышенной точности, например, для денежных данных. M — количество отводимых под число символов (максимальное значение — 64). D — количество знаков после запятой (максимальное значение — 30).Пример: DECIMAL (5,2) — будет хранить числа от -99,99 до 99,99.
FLOAT (M,D)	4 байта	мин. значение +(-) 1.175494351 * 10-39 макс. значение +(-) 3. 402823466 * 1038	Вещественное число (с плавающей точкой). Может иметь параметр UNSIGNED, запрещающий отрицательные числа, но диапазон значений от этого не изменится. M — количество отводимых под число символов. D — количество символов дробной части. Пример: FLOAT (5,2) — будет хранить числа из 5 символов, 2 из которых будут идти после запятой (например: 46,58).
DOUBLE (M,D)	8 байт	мин. значение +(-) 2.2250738585072015 * 10-308 макс. значение +(-) 1.797693134862315 * 10308	Аналогично предыдущему, но с большим диапазоном. Пример: DOUBLE — будет хранить большие дробные числа.

Программирование. Числовые типы данных Pascal-Паскаль

Однако она хранит только положительные числа, поэтому вмещает диапазон чисел от 0 до 65,535 (2^16) — 1).

Word

Описание

word хранит 16-бит положительное число, от 0 до 65536. Также как и unsigned int.

Long

Описание:

Long это расширенный тип данных целочислительной переменной. Занимает 32 бит (4 байта и может хранить числа от -2,147,483,648 до 2,147,483,647.

Unsigned long

Описание:

Unsigned long это расширенный тип данных положительной целочислительной переменной, занимающий 32 бит (4 байт).Может хранить положительные значения от 0 до 4,294,967,295 (2^32 — 1).

Float

Описание:

Тип данных для хранения чисел с плавающей точкой. Числа с плавающей точкой имеют гораздо большее разрешение чем целочисленные переменные. Такие числа могут быть величиной до 3.4028235E+38 от -3.4028235E+38. Они занимают 32 бит (4 байт) данных.

Числа с плавающей точкой не точны и операция 6,0/2,0 не всегда вернет 2,0. Вы должны учитывать погрешность при сравнении двух чисел.

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

Double

Описание

Double это тип данных переменной с плавающей точкой двойной точности. Однако, в Arduino на данный момент, точность double аналогична точности float — т.е. занимает 4 байта.

String

Описание

Строки это массивы символов, завершающиеся нулевым сиволом

Пример

Ниже представлены все правильные объявления переменных типа char.

char Str1;

char Str2 = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’};

char Str3 = {‘a’, ‘r’, ‘d’, ‘u’, ‘i’, ‘n’, ‘o’, ‘\0’};

char Str4 = «arduino»;

char Str5 = «arduino»;

char Str6 = «arduino»;

Возможности для объявления массивов

Объявление массива символов без занесения в него данных, Str1

Объявление массива символов с одной свободной ячейкой — компилятор автоматически добавит туда нулевой символ, Str2

Явное добавление нулевого символа, Str3

Инициализация массива без указания длинны, компилятор сам посчитает необходимое количество ячееек, плюс поставит нулевой символ, Str4

Инициализация массива я явным указанием длины массива и занесением в массив строковой константы, Str5

Инициализация массива, со свободным местом для более длинных строк, Str6

Предыдущая78910111213141516171819202122Следующая

Дата добавления: 2015-03-23; просмотров: 390;

Перечислимый тип

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

Type <имя типа>=(список констант);
Var <имя переменной>:<имя типа>;

где <список констант> — это особый вид констант, задаваемых через запятую и имеющих свой порядковый номер, начиная с 0.

Например:

type
направление=(север, юг, запад, восток);
месяц=(июнь,июль,август,январь);
емкость=(ведро,бочка,канистра,бак);
var
поворот:направление;
отъезд:месяц;
объем:емкость;

или так:

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

Можно выполнить такие операторы присваивания:

поворот:=юг;
отъезд:=август;
объем:=бак;

но нельзя выполнять смешанные присваивания:

отъезд:=юг;
объем:=август;

К переменным перечислимого типа применимы следующие функции:

1. ORD — порядковый номер

2. PRED — предшествующий элемент

3. SUCC — последующий элемент.

Пример:

PRED(бочка)=ведро; 
SUCC(юг)=запад; 
ORD(июль)=1;

Переменные перечислимого типа можно сравнить, так как они упорядочены и пронумерованы. Так выражения: север < юг, июнь < январь имеют значения TRUE, а юг>запад и бак<бочка значение FАLSE.

Размер основных типов данных в C++

Возникает вопрос: «Сколько памяти занимают переменные разных типов данных?». Вы можете удивиться, но размер переменной с любым типом данных зависит от компилятора и/или архитектуры компьютера!

Язык C++ гарантирует только их минимальный размер:

Категория	Тип	Минимальный размер
Логический тип данных	bool	1 байт
Символьный тип данных	char	1 байт
	wchar_t	1 байт
	char16_t	2 байта
	char32_t	4 байта
Целочисленный тип данных	short	2 байта
	int	2 байта
	long	4 байта
	long long	8 байт
Тип данных с плавающей запятой	float	4 байта
	double	8 байт
	long double	8 байт

Фактический размер переменных может отличаться на разных компьютерах, поэтому для его определения используют оператор sizeof.

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

#include <iostream>

int main()
{
std::cout << «bool:\t\t» << sizeof(bool) << » bytes» << std::endl;
std::cout << «char:\t\t» << sizeof(char) << » bytes» << std::endl;
std::cout << «wchar_t:\t» << sizeof(wchar_t) << » bytes» << std::endl;
std::cout << «char16_t:\t» << sizeof(char16_t) << » bytes» << std::endl;
std::cout << «char32_t:\t» << sizeof(char32_t) << » bytes» << std::endl;
std::cout << «short:\t\t» << sizeof(short) << » bytes» << std::endl;
std::cout << «int:\t\t» << sizeof(int) << » bytes» << std::endl;
std::cout << «long:\t\t» << sizeof(long) << » bytes» << std::endl;
std::cout << «long long:\t» << sizeof(long long) << » bytes» << std::endl;
std::cout << «float:\t\t» << sizeof(float) << » bytes» << std::endl;
std::cout << «double:\t\t» << sizeof(double) << » bytes» << std::endl;
std::cout << «long double:\t» << sizeof(long double) << » bytes» << std::endl;
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <iostream>

intmain()

{

std::cout<<«bool:\t\t»<<sizeof(bool)<<» bytes»<<std::endl;

std::cout<<«char:\t\t»<<sizeof(char)<<» bytes»<<std::endl;

std::cout<<«wchar_t:\t»<<sizeof(wchar_t)<<» bytes»<<std::endl;

std::cout<<«char16_t:\t»<<sizeof(char16_t)<<» bytes»<<std::endl;

std::cout<<«char32_t:\t»<<sizeof(char32_t)<<» bytes»<<std::endl;

std::cout<<«short:\t\t»<<sizeof(short)<<» bytes»<<std::endl;

std::cout<<«int:\t\t»<<sizeof(int)<<» bytes»<<std::endl;

std::cout<<«long:\t\t»<<sizeof(long)<<» bytes»<<std::endl;

std::cout<<«long long:\t»<<sizeof(longlong)<<» bytes»<<std::endl;

std::cout<<«float:\t\t»<<sizeof(float)<<» bytes»<<std::endl;

std::cout<<«double:\t\t»<<sizeof(double)<<» bytes»<<std::endl;

std::cout<<«long double:\t»<<sizeof(longdouble)<<» bytes»<<std::endl;

return;

}

Вот результат, полученный на моем компьютере:

Ваши результаты могут отличаться, если у вас другая архитектура, или другой компилятор

Обратите внимание, оператор sizeof не используется с типом void, так как последний не имеет размера

Если вам интересно, что значит в коде, приведенном выше, то это специальный символ, который используется вместо клавиши TAB. Мы его использовали для выравнивания столбцов. Детально об этом мы еще поговорим на соответствующих уроках.

Интересно то, что sizeof — это один из 3-х операторов в языке C++, который является словом, а не символом (еще есть new и delete).

Вы также можете использовать оператор sizeof и с переменными:

#include <iostream>

int main()
{
int x;
std::cout << «x is » << sizeof(x) << » bytes» << std::endl;
}

1
2
3
4
5
6
7

#include <iostream>

intmain()

{

intx;

std::cout<<«x is «<<sizeof(x)<<» bytes»<<std::endl;

}

Результат выполнения программы:

На следующих уроках мы рассмотрим каждый из фундаментальных типов данных языка С++ по отдельности.

Целое число

Целые числа — это целые числа. Они могут быть положительными или отрицательными. Они должны быть без десятичных значений.

Мы можем использовать функцию int(), чтобы получить целочисленное представление объекта. В объекте должен быть реализован метод __int __(), который возвращает целое число.

Давайте рассмотрим несколько примеров.

x = 10
print(type(x))

x = int("10")
print(type(x))


class Data:
    id = 0

    def __init__(self, i):
        self.id = i

    def __int__(self):
        return self.id


d = Data(10)

x = int(d)
print(x)
print(type(x))

Вывод:

<class 'int'>
<class 'int'>
10
<class 'int'>

Класс String предоставляет метод __int __(), поэтому мы можем легко преобразовать строку в int с помощью метода int().

Если объект не реализует метод __int __(), функция int() выдает ошибку TypeError.

Обычно целые числа определяются на основе 10. Но мы также можем определять их в двоичном, восьмеричном и шестнадцатеричном формате.

i = 0b1010
print(i)  # 10

i = 0xFF
print(i)  # 255

i = 0o153
print(i)  # 107

Класс Boolean

Тип практически такой же, как тип . Отличия минимальны.

Ниже мы покажем упрощенный вариант класса :

Код	Описание
	Константы: и Переменная-значение Конструктор класса Метод возвращает значение внутренней переменной-значения Этот статический метод умеет преобразовывать в и в .

В типе есть две константы (два поля):

Константы класса	Аналог типа boolean	Описание
		истина
		ложь

Работать с ними можно так же, как и с типом :

Код	Примечание
	— единственный класс, который можно писать внутри условия
	Все три переменные равны /
	Константы можно сравнивать и через и через Так тоже будет работать.

Autoboxing тут работает отлично, поэтому можете пользоваться этим типом так же, как типом : никаких подводных камней тут нет.

Как записано	Как это работает

А вот как происходят сравнения между типами и :

Если очень нужно создать независимый объект , то надо создать его явно:

И еще один пример: использование внутри :

Код	Примечание
	Скомпилируется и будет работать

Скомпилируется, но работать не будет:

Код	Примечание
	Ошибка. В этой строке кинется исключение