Переменная типа char в C++ для начинающих и как с ней работать
При написании прошлой статьи по обработке файла мною была использована переменная типа char
У меня как у начинающего изучение сразу возникли некоторые трудности обработки этой переменной. Самый первый вопрос передо мной встал так – а как вывести переменную char на экран. Почему-то при поиске я натыкался на подробное описание переменной и какие-то мудренные примеры обработки. Хотя меня первым делом интересовала информация, как в C++ вывести на экран переменную, содержащую, например, только одну букву.
Для присвоения переменной типа char какого-то значения внутри кода программы используют знак умножения * – этим переменная типа char отличается от численных значений.
Например, мне нужно в коде программы указать, что на каком-то этапе работы программы, переменная s1 должна принять значение Буква y. (Именно буква)
Я стал пробовать работать s1 как с обычными переменными и написал где-то там внутри кода:
Программирование на Си. #9. Особенности Char.
char s1;
s1=”y”;
На что при попытке выполнить программу – мне было объявленно, что в этом месте кода ошибка.
Я стал рыскать, что я делаю не так и нашел много разнообразного материала, но всё почему-то было не то. Возможно я не умею искать, но найденные примеры были очень разнообразны
Примеры с указателями, различными преобразованиями и хитрыми функциями
Такие примеры мне не нравятся. Простота – вот то, что мне нужно.
Оказалось, что всё очень просто:
Привожу пример кода, выводящий на экран введенную букву y
#include
int main()
clrscr(); //Очищаем экран
char s1; //Объявляем переменную s1
s1[0]=*”y” //Присвоение переменной s1 значения
coutВыводим букву y на экран
return 0;
>
Настолько всё оказалось просто, перед знаком = нужно было поставить знак * и нужнобыло объявить номер элемента (ноль соответствет первому)
Но переменную char чаще используют как массив каких-то символьных значений. Знакомство с простым массивом было изложено в статье
Одномерный массив в C++ для начинающих
Для работы с массивами часто необходимо использовать циклы. В прошлой статье был использован цикл for. Про ккотрый описано в статье
Цикл for в С++ для начинающих
Т.е. часто символьную переменную объявляют как набор одинарных символов. Даже строковая переменная, о которой я когда-нибудь тоже напишу – это не более чем набор значений типа char
Первоначально лучше изучить как работать и как использовать именно символьную переменную типа char, а потом уже изучать строковую. Посимвольное считывание из каких-то источников очень часто используется в программировании, поэтому это важный этап.
Есть много технической литературы, где правильно и глубоко описывается принцип работы и главная идея переменной char , но я считаю, углубляться пока не особо нужно. Но важно знать как при необходимости присваивать значения переменной.
Второй вопрос передо мной встал как – а как обнулить переменную типа char в C++ ?, при поиске я почему-то натыкался на исходник целой функции, которая была написана не самым понятным для новичков языком. На этот вопрос я легко смог ответить, когда понял как такой переменной присваивать значения.
Curso de C — Tipo de dato char
т.е. Если у нас переменная s1 равна Буква y, но нам нужно её очистить, то мы это делаем так
s1=*””
Ставим знак равенства, ставим звездочку и ставим две двойные кавычки подряд
Две двойные кавычки подряд соответсвтуют обнулению значения в символьных переменных.
Так как переменную типа char часто используют как массив, то определяют количество возможных значений.
Например, код
int main()
char s1 [100]; //Объявляем переменную s1
return 0;
>
Почти равносилен тому, что мы объявили строку, состоящую из 101 символа.
Если не понимаете почему 101, а не 100 – лучше изучайте массивы. Напоминаю пример простого массива приведен в одной из прошлых статей Одномерный массив в C++ для начинающих
Есть небольшой нюанс при обработке массива. Так как для обработки мы используем цикл, то если объявленный нами символьный Массив типа char в 101 символ, содержит, например, 5 символов, то неразумно использовать цикл пока мы не достигнем конца нашего массива. – Потомучто если в программе будут тысячи таких операций – это существенно замедлит скорость работы программы
При объявлении любой переменной, переменной отводится какой-то участок памяти и память эта может уже содержать какое-то значение. Это значение не обязательно пустое или ноль и по умолчанию очень легко присвоится нашей переменной.
Поэтому любые переменные при объявлении правильно обнулять.
Для того, чтобы обнулить наш символьный массив s1 типа Char на языке программирования C++, после его объявления мы пишем такой код
===============
Программа обнуления массива типа char
int main()
char s1 [100]; //Объявляем переменную s1
(for int i=0;i <=100;i++) s1[i]=*””;
return 0;
>
==============
Преимущество этого кода в том, что теперь мы можем определить окончание заполненных ячеек массива, независимо от того, сколько их объявлено. Для этого мы должны указывать условие, что если ячейка пустая, то значит можно прекращать работу с этим массивом и перехоить к дальнейшим действиям. Соответственно количество операций и нагрузка на процессор существенно уменьшаются.
Источник: ciplusplussnachala.wordpress.com
4.11 – Символы
На данный момент базовые типы данных, которые мы рассмотрели, использовались для хранения чисел (целые числа и числа с плавающей запятой) или значений истина/ложь (логические значения). Но что, если мы хотим хранить буквы?
#include int main() < std::cout
Для хранения символов был разработан тип данных char . Символом может быть одна буква, цифра, знак или пробел.
Тип данных char является целочисленным типом, что означает, что базовое значение хранится как целое число. Подобно тому, как логическое значение 0 интерпретируется как false , а ненулевое значение интерпретируется как true , целое число, хранимое переменной char , интерпретируется как символ ASCII.
ASCII расшифровывается как American Standard Code for Information Interchange (Американский стандартный код для обмена информацией) и определяет конкретный способ представления английских символов (плюс несколько других символов) в виде чисел от 0 до 127 (называемых кодом ASCII или кодовым обозначением). Например, код ASCII 97 интерпретируется как символ ‘ а ‘.
Символьные литералы всегда помещаются в одинарные кавычки (например, ‘ g ‘, ‘ 1 ‘, ‘ ‘).
Ниже приведена полная таблица символов ASCII:
Коды 0–31 называются непечатаемыми символами и в основном используются для форматирования и управления принтерами. Большинство из них сейчас устарели.
Коды 32–127 называются печатными символами и представляют собой буквы, цифры и знаки препинания, которые большинство компьютеров используют для отображения основного английского текста.
Инициализация переменных char
Вы можете инициализировать переменные типа char , используя символьные литералы:
// инициализировать кодовым обозначением для ‘a’ (хранится как целое число 97) (предпочтительно) char ch2 ;
Вы также можете инициализировать переменные типа char целыми числами, но этого, если возможно, следует избегать.
// инициализировать целым числом 97 (‘a’) (не рекомендуется) char ch1 ;
Предупреждение
Будьте осторожны, чтобы не перепутать символы чисел с целыми числами. Следующие две инициализации не эквивалентны:
char ch ; // инициализируем целым числом 5 (сохраняется как целое число 5) char ch ; // инициализируем кодовым обозначением для ‘5’ (хранится как целое число 53)
Символы чисел предназначены для использования, когда мы хотим представить числа в виде текста, а не в виде чисел и применения к ним математических операций.
Печать переменных типа char
При использовании std::cout для печати переменной типа char , std::cout выводит переменную char как символ ASCII:
#include int main() < char ch1< ‘a’ >; // (предпочтительно) std::cout ; // кодовое обозначение для ‘b’ (не рекомендуется) std::cout
Данная программа дает следующий результат:
Мы также можем напрямую выводить символьные литералы:
cout
В результате это дает:
Напоминание
В C++ целочисленный тип фиксированной ширины int8_t обычно обрабатывается так же, как signed char , поэтому он обычно печатается как символ ( char ) вместо целого числа.
Печать переменных char как целых чисел через приведение типов
Если мы хотим вывести char как число вместо символа, мы должны указать std::cout , чтобы он печатал переменную char , как если бы она была целочисленного типа. Один (плохой) способ сделать это – присвоить значение переменной char другой переменной целочисленного типа и напечатать эту переменную:
#include int main() < char ch; int i; // инициализируем целочисленную переменную значением ch std::cout
Однако это довольно коряво. Лучше использовать приведение типа. Приведение типа создает значение одного типа из значения другого типа. Для преобразования между базовыми типами данных (например, из char в int или наоборот) мы используем приведение типа, называемое статическим приведением.
Синтаксис статического приведения выглядит немного забавным:
static_cast(выражение)
static_cast принимает значение из выражения в качестве входных данных и преобразует его в любой базовый тип, который представляет новый_тип (например, int , bool , char , double ).
Ключевые выводы
Всякий раз, когда вы видите синтаксис C++ (за исключением препроцессора), в котором используются угловые скобки, то, что между угловыми скобками, скорее всего, будет типом. Обычно C++ работает с концепциями, которым нужен параметризуемый тип.
Ниже показан пример использования статического приведения для создания целочисленного значения из нашего значения char :
#include int main() < char ch< ‘a’ >; std::cout (ch)
Эта программа дает следующий вывод:
a 97 a
Важно отметить, что параметр static_cast вычисляется как выражение. Когда мы передаем переменную, эта переменная вычисляется для получения ее значения, которое затем преобразуется в новый тип. На переменную не влияет приведение ее значения к новому типу. В приведенном выше случае переменная ch по-прежнему является char и сохраняет то же значение.
Также обратите внимание, что статическое приведение не выполняет никакой проверки диапазона значений, поэтому, если вы приведете большое целое число в char , вы вызовете переполнение своей переменной char .
О статическом приведении типов и других типах приведения мы поговорим подробнее в следующем уроке (8.5 – Явное преобразование типов (приведение) и static_cast ).
Ввод символов
Следующая программа просит пользователя ввести символ, а затем печатает его как символ и его код ASCII:
#include int main() < std::cout ; std::cin >> ch; std::cout (ch)
Ниже показан результат одного запуска:
Input a keyboard character: q q has ASCII code 113
Обратите внимание, что std::cin позволяет вводить несколько символов. Однако переменная ch может содержать только 1 символ. Следовательно, в переменную ch извлекается только первый входной символ. Остальная часть пользовательского ввода остается во входном буфере, который использует std::cin , и может быть извлечена с помощью последующих вызовов std::cin .
Вы можете увидеть это поведение в следующем примере:
#include int main() < std::cout ; std::cin >> ch; // ch = ‘a’, «bcd» остается в очереди std::cout (ch) > ch; // ch = ‘b’, «cd» остается в очереди std::cout (ch)
Input a keyboard character: abcd a has ASCII code 97 b has ASCII code 98
Размер, диапазон и символ по умолчанию у переменных char
char определяется C++ всегда размером 1 байт. По умолчанию char может быть со знаком или без знака (хотя обычно он со знаком).
Если вы используете переменные char для хранения символов ASCII, вам не нужно указывать знак (поскольку переменные char со знаком и без знака могут содержать значения от 0 до 127).
Если вы используете char для хранения небольших целых чисел (чего не следует делать, если вы явно не оптимизируете используемую память), вы всегда должны указывать, со знаком переменная или нет. signed char (со знаком) может содержать число от -128 до 127. unsigned char (без знака) может содержать число от 0 до 255.
Экранированные последовательности
В C++ есть некоторые символы, которые имеют особое значение. Эти символы называются экранированными последовательностями (управляющими последовательностями, escape-последовательностями). Экранированная последовательность начинается с символа » (обратный слеш), за которым следует буква или цифра.
Вы уже видели наиболее распространенную экранированную последовательность: ‘ n ‘, которую можно использовать для вставки символа новой строки в текстовую строку:
#include int main()
Эта программа выдает:
First line Second line
Еще одна часто используемая экранированная последовательность – ‘ t ‘, которая включает горизонтальную табуляцию:
#include int main()
First part Second part
Три других примечательных экранированных последовательности:
- ‘ – печатает одинарную кавычку;
- » – печатает двойную кавычку;
- \ – печатает обратный слеш.
Ниже приведена таблица всех экранированных последовательностей:
| Предупреждение | a | Выдает предупреждение, например звуковой сигнал |
| Backspace | b | Перемещает курсор на одну позицию назад |
| Перевод страницы | f | Перемещает курсор на следующую логическую страницу |
| Новая строка | n | Перемещает курсор на следующую строку |
| Возврат каретки | r | Перемещает курсор в начало строки |
| Горизонтальная табуляция | t | Печать горизонтальной табуляции |
| Вертикальная табуляция | v | Печатает вертикальную табуляцию |
| Одинарная кавычка | ‘ | Печать одинарной кавычки |
| Двойная кавычка | « | Печать двойной кавычки |
| Обратная косая черта | \ | Печатает обратный слеш |
| Вопросительный знак | ? | Печатает вопросительный знак Больше не актуально. Вы можете использовать вопросительные знаки без экранирования. |
| Восьмеричное число | (число) | Преобразуется в символ, представленный восьмеричным числом |
| Шестнадцатеричное число | x(число) | Преобразуется в символ, представленный шестнадцатеричным числом |
Вот несколько примеров:
#include int main()
Эта программа напечатает:
«This is quoted text» This string contains a single backslash 6F in hex is char ‘o’
Новая строка ( n ) против std::endl
В чем разница между заключением символов в одинарные и двойные кавычки?
Отдельные символы всегда заключаются в одинарные кавычки (например, ‘a’, ‘+’, ‘5’). char может представлять только один символ (например, букву а, знак плюса, цифру 5). Что-то вроде этого некорректно:
char ch; // char может содержать только один символ
Текст, заключенный в двойные кавычки (например, «Hello, world!»), называется строкой. Строка – это набор последовательных символов (и, таким образом, строка может содержать несколько символов).
Пока вы можете использовать строковые литералы в своем коде:
std::cout
Мы обсудим строки в следующем уроке (4.12 – Знакомство с std::string ).
Правило
Всегда помещайте отдельные символы в одинарные кавычки (например, ‘ t ‘ или ‘ n ‘, а не » t » или » n «). Это помогает компилятору более эффективно выполнять оптимизацию.
А как насчет других типов символов, wchar_t , char16_t и char32_t ?
wchar_t следует избегать почти во всех случаях (за исключением взаимодействия с Windows API). Его размер определяется реализацией и не является надежным. Он не рекомендуется для использования.
В качестве отступления.
Англоязычный термин «deprecated» (не рекомендуется) означает «всё еще поддерживается, но больше не рекомендуется для использования, потому что он был заменен чем-то лучшим или больше не считается безопасным».
Подобно тому, как ASCII сопоставляет целые числа 0–127 с символами английского алфавита, существуют и другие стандарты кодировки символов для сопоставления целых чисел (разного размера) с символами других языков. Наиболее известной кодировкой за пределами диапазона ASCII является стандарт Unicode (Юникод), который сопоставляет более 110 000 целых чисел с символами на многих языках. Поскольку Unicode содержит очень много кодовых обозначений, то для одного кодового обозначения, чтобы представить один символ, Unicode требуется 32 бита (кодировка UTF-32). Однако символы Unicode также могут быть закодированы с использованием 16-ти или 8-ми битов (кодировки UTF-16 и UTF-8 соответственно).
char16_t и char32_t были добавлены в C++11 для обеспечения явной поддержки 16-битных и 32-битных символов Unicode. char8_t был добавлен в C++20.
Если вы не планируете сделать свою программу совместимой с Unicode, вам не нужно использовать char8_t , char16_t или char32_t . Юникод и локализация в основном выходят за рамки этих руководств, поэтому мы не будем рассматривать их дальше.
А пока при работе с символами (и строками) вы должны использовать только символы ASCII. Использование символов из других наборов символов может привести к неправильному отображению ваших символов.
Источник: radioprog.ru
Урок №35. Символьный тип данных char
Хоть тип char и относится к целочисленным типам данных (и, таким образом, следует всем их правилам), работа с char несколько отличается от работы с обычными целочисленными типами.
Тип данных char
Переменная типа char занимает 1 байт. Однако вместо конвертации значения типа char в целое число, оно интерпретируется как ASCII-символ.
ASCII (сокр. от « A merican S tandard C ode for I nformation I nterchange» ) — это американский стандартный код для обмена информацией, который определяет способ представления символов английского языка (+ несколько других) в виде чисел от 0 до 127. Например: код буквы ‘а’ — 97, код буквы ‘b’ — 98. Символы всегда помещаются в одинарные кавычки.
Таблица ASCII-символов :
Символы от 0 до 31 в основном используются для форматирования вывода. Большинство из них уже устарели.
Символы от 32 до 127 используются для вывода. Это буквы, цифры, знаки препинания, которые большинство компьютеров использует для отображения текста (на английском языке).
Следующие два стейтмента выполняют одно и то же (присваивают переменным типа char целое число 97 ):
Будьте внимательны при использовании фактических чисел с числами, которые используются для представления символов (из ASCII-таблицы). Следующие два стейтмента выполняют не одно и то же:
Вывод символов
При выводе переменных типа char, объект cout выводит символы вместо цифр:
Также вы можете выводить литералы типа char напрямую:
Оператор static_cast
Если вы хотите вывести символы в виде цифр, а не в виде букв, то вам нужно сообщить cout выводить переменные типа char в виде целочисленных значений. Не очень хороший способ это сделать — присвоить переменной типа int переменную типа char и вывести её:
Лучшим способом является конвертация переменной из одного типа данных в другой с помощью оператора static_cast .
Синтаксис static_cast выглядит следующим образом:
Оператор static_cast принимает значение из (выражения) в качестве входных данных и конвертирует его в указанный вами .
Пример использования оператора static_cast для конвертации типа char в тип int:
Результат выполнения программы:
Запомните, static_cast принимает (выражение) в качестве входных данных. Если мы используем переменную в (выражении) , то эта переменная изменяет свой тип только в стейтменте с оператором static_cast. Процесс конвертации никак не влияет на исходную переменную с её значением! В вышеприведенном примере, переменная ch остается переменной типа char с прежним значением, чему является подтверждением последний стейтмент с cout.
Также в static_cast нет никакой проверки по диапазону, так что если вы попытаетесь использовать числа, которые будут слишком большие или слишком маленькие для конвертируемого типа, то произойдет переполнение .
Более подробно о static_cast мы еще поговорим на соответствующем уроке.
Ввод символов
Следующая программа просит пользователя ввести символ. Затем она выводит этот символ и его ASCII-код:
Результат выполнения программы:
Input a keyboard character: q
q has ASCII code 113
Обратите внимание, даже если cin позволит вам ввести несколько символов, переменная ch будет хранить только первый символ (именно он и помещается в переменную). Остальная часть пользовательского ввода останется во входном буфере, который использует cin, и будет доступна для использования последующим вызовам cin.
Рассмотрим это всё на практике:
Результат выполнения программы:
Input a keyboard character: abcd
a has ASCII code 97
b has ASCII code 98
Размер, диапазон и знак типа сhar
В языке С++ для переменных типа char всегда выделяется 1 байт. По умолчанию, char может быть как signed, так и unsigned (хотя обычно signed). Если вы используете char для хранения ASCII-символов, то вам не нужно указывать знак переменной (поскольку signed и unsigned могут содержать значения от 0 до 127).
Но если вы используете тип char для хранения небольших целых чисел, то тогда следует уточнить знак. Переменная типа char signed может хранить числа от -128 до 127. Переменная типа char unsigned имеет диапазон от 0 до 255.
Управляющие символы
В языке C++ есть управляющие символы (или «escape-последовательности» ). Они начинаются с бэкслеша ( ), а затем следует определенная буква или цифра.
Наиболее распространенным управляющим символов в языке С++ является ‘n’ , который обозначает символ новой строки:
First line
Second line
Еще одним часто используемым управляющим символом является t , который заменяет клавишу TAB, вставляя большой отступ:
First part Second part
Таблица всех управляющих символов в языке C++ :
Рассмотрим пример в коде:
Результат выполнения программы:
«This is quoted text»
This string contains a single backslash
6F in hex is char ‘o’
Что использовать: ‘n’ или std::endl?
Вы могли заметить, что в последнем примере мы использовали ‘n’ для перемещения курсора на следующую строку. Но мы могли бы использовать и std::endl . Какая между ними разница? Сейчас разберемся.
При использовании std::cout, данные для вывода могут помещаться в буфер, т.е. std::cout может не отправлять данные сразу же на вывод. Вместо этого он может оставить их при себе на некоторое время (в целях улучшения производительности).
И ‘n’ , и std::endl оба переводят курсор на следующую строку. Только std::endl еще гарантирует, что все данные из буфера будут выведены, перед тем, как продолжить.
Так когда же использовать ‘n’ , а когда std::endl ?
Используйте std::endl , когда нужно, чтобы ваши данные выводились сразу же (например, при записи в файл или при обновлении индикатора состояния какого-либо процесса). Обратите внимание, это может повлечь за собой незначительное снижение производительности, особенно если запись на устройство происходит медленно (например, запись файла на диск).
Используйте ‘n’ во всех остальных случаях.
Другие символьные типы: wchar_t, char16_t и char32_t
Тип wchar_t следует избегать практически во всех случаях (кроме тех, когда происходит взаимодействие с Windows API).
Так же, как и стандарт ASCII использует целые числа для представления символов английского языка, так и другие кодировки используют целые числа для представления символов других языков. Наиболее известный стандарт (после ASCII) — Unicode , который имеет в запасе более 110 000 целых чисел для представления символов из разных языков.
Существуют следующие кодировки Unicode :
- UTF-32 — требует 32 бита для представления символа.
- UTF-16 — требует 16 бит для представления символа.
- UTF-8 — требует 8 бит для представления символа.
Типы char16_t и char32_t были добавлены в C++11 для поддержки 16-битных и 32-битных символов Unicode (8-битные символы и так поддерживаются типом char).
В чём разница между одинарными и двойными кавычками при использовании с символами?
Как вы уже знаете, символы всегда помещаются в одинарные кавычки (например, ‘а’ , ‘+’ , ‘5’ ). Переменная типа char представляет только один символ (например, буква а , символ + , число 5 ). Следующий стейтмент не является корректным:
Текст, который находится в двойных кавычках, называется строкой (например, «Hello, world!» ). Строка (тип string ) — это набор последовательных символов.
Вы можете использовать литералы типа string в коде:
Более подробно о типе string мы поговорим на соответствующем уроке.
Источник: dzen.ru
Урок 13. Символьный тип данных (char) C#
На этом уроке учебника по C# мы возвращаемся к теме типы данных. В этой статье рассматривается тип символьных данных, который позволяет нам начать пересечение границы между числовыми значениями и представлениями текстовой информации.
Формат ASCII
В 1967 году был опубликован американский стандартный код для обмена информацией (ASCII символы. ASCII определяет число, представляющее каждую английскую букву, цифру и различные знаки препинания. Этот код содержит ряд непечатаемых управляющих символов, позволяющих управлять устройствами, например принтерами. Примерами управляющих символов являются символ 13, представляющий возврат каретки, и символ 10 для перехода строки.
ASCII использует диапазон чисел от нуля до ста двадцати шести, чтобы представлять как печатные, так и непечатные символы. Каждый символ может храниться в семи двоичных цифрах информации. В большинстве языков программирования, поддерживающих символьный тип данных, для представления символа ASCII можно использовать один байт.
Юникод является более новым стандартом для кодирования текста. Unicode позволяет отображать намного больше символов, чем ASCII, включая международные буквы и символы, не используемые в английском языке. Если для некоторых языков требуется несколько тысяч символов, одного байта на символ недостаточно для кодирования. Таким образом, Unicode использует два или более байт для больших наборов символов.
Символьный тип данных
Символьный или тип char тип данных, определенный в языке C# используется для хранения одного символа Unicode. Символьные переменные содержат шестнадцатиразрядное число, представляющее букву, цифру, символ или управляющий символ. Они могут также рассматриваться как числовой тип данных с аналогичными свойствами в беззнаковое короткое целое число.
Значения могут быть присвоены символьной переменной с помощью оператора Normal assignment (=, оператор присваивания). Поскольку тип данных обеспечивает пересечение между числовой и текстовой информацией, информация может быть назначена двумя способами. Для прямого назначения символа можно использовать одну букву, число или символ, окруженный апострофом(‘). Целочисленные значения могут также использоваться, но должны приводиться к типу char.
char letterA; letterA = ‘A’; // присваиваем символ напрямую letterA = (char)65; // присваиваем число через char
В приведенном выше примере показаны два метода, с помощью которых значение может быть присвоено символьной переменной. Фактически, две операции присваивания выполняют одну и ту же задачу; символ юникода, представленный числом шестьдесят пять, является заглавной буквой «а». Это может быть продемонстрировано дальнейшим преобразованием результирующего символа обратно в числовое или символьное представление и отображения её.
char letterA; letterA = ‘A’; Console.WriteLine(letterA); // Выведет «A»; Console.WriteLine((int)letterA); // Выведет «65»;
C# 2.0 допускающий значение NULL
Ранее в данном руководстве мы рассмотрели обнуляемыми числовые типы данных, которые были введены при .Net версии 2.0. Тип символьных данных имеет значение NULL с аналогичной функциональностью.
char? c; c = ‘A’; c = null;
Автор этого материала — я — Пахолков Юрий. Я оказываю услуги по написанию программ на языках Java, C++, C# (а также консультирую по ним) и созданию сайтов. Работаю с сайтами на CMS OpenCart, WordPress, ModX и самописными. Кроме этого, работаю напрямую с JavaScript, PHP, CSS, HTML — то есть могу доработать ваш сайт или помочь с веб-программированием. Пишите сюда.
статьи IT, Уроки по си шарп, си шарп
Источник: upread.ru