Переменная типа char в C++ для начинающих и как с ней работать

Опубликовано 29.07.2011 | Автор: admin

У меня, как начинающего изучение С++, сразу возникли трудности обработки переменной типа char. Самый мой первый вопрос: "А как вывести переменную типа char на экран?".

Несмотря на минимальную потребность: вывести на экран только одну, например, букву, поиск мне выдавал страницы с подробным описанием типа char или с очень мудрёнными кодами.

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

Для сохранения переменной типа char используют такой код:

    char ch = 'z'; //Сохранение символа 'z' в переменную ch

1	char ch = 'z'; //Сохранение символа 'z' в переменную ch

    char ch = 0; //Обнуление ch, не сохранения символа ноля!

1	char ch = 0; //Обнуление ch, не сохранения символа ноля!

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

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

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

Любой отдельный символ, представленный в C++ как char, на самом деле обычное число. Любые операции (сложение, вычитание…), применяемые к обычным целым числам, можно применять к символам char.

Почему C++ выводит число как символ? Это не С++ выводит число как символ, а cout показывает char как символы.

//Тип char - это целые числа, представляемые людям как символы      Листинг #1
    int main(){
    char ch = 1;  // Присвоили в ch число 1, символ, выводимый на экран будет иным
    cout << ch << "\n";
    }

//Тип char - это целые числа, представляемые людям как символы Листинг #1

int main(){

char ch = 1; // Присвоили в ch число 1, символ, выводимый на экран будет иным

cout << ch << "\n";

}

Именно проблема, описываемая в листинге #1, вводила меня в заблуждение, наверняка кого-то вводит ещё. Это характерная ошибка новичков: не указать символьное обозначение сохраняемому значению. Из-за того, что символьные переменные по факту числа, компиляторы С++ никак не противятся сохранению в числовой тип чисел.

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

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

//Тип char - это целые числа, представляемые людям как символы      Листинг #2
#include <iostream.h>
int main(){
    char ch = '1';  // Присвоили в ch символ '1', символ, выводимый на экран, будет '1'
    cout << ch << "\n";
}

//Тип char - это целые числа, представляемые людям как символы Листинг #2

#include <iostream.h>

int main(){

char ch = '1'; // Присвоили в ch символ '1', символ, выводимый на экран, будет '1'

cout << ch << "\n";

}

Бывает, что новичок, плохо знающий основы языка С++, для сохранения в символьную переменную использует код, похожий на вот этот:

    char ch = *"F";

1	char ch = *"F";

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

Пример, демонстрирующий различие:

//Borland C++ 3.1       Выдёргивание первого символа строки с сохранением
                     // в переменную         //Листинг #3
#include <iostream.h>
int main(){
    char ch = *"Privet";
    cout << ch; //На вывод только P
}

//Borland C++ 3.1 Выдёргивание первого символа строки с сохранением

// в переменную //Листинг #3

#include <iostream.h>

int main(){

char ch = *"Privet";

cout << ch; //На вывод только P

}

//Листинг #4
char ch= *'Privet'; //Ошибка. Одиночные кавычки для одиночных символов и
                    //для спецсимволов: '\n','\t' и т. п.

//Листинг #4

char ch= *'Privet'; //Ошибка. Одиночные кавычки для одиночных символов и

//для спецсимволов: '\n','\t' и т. п.

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

    char s1;
    s1 = "y"; //Ошибочная попытка сохранить символ 'y' в ch

1 2	char s1; s1 = "y"; //Ошибочная попытка сохранить символ 'y' в ch

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

Даже пустая строка в C++ воспринимается компилятором как нечто, содержащее внутри себя много символов, хотя хранится внутри только один символ, признак конца строки

    char ch = ""; //Ошибка

1	char ch = ""; //Ошибка

Ошибка происходит из-за разнобоя в типах данных: в char происходит попытка сохранить char[1], компилятор С++ считает, что char[1] слишком большой для char и не даёт возможности такого сохранения.

К сожалению, компиляторы допускают ошибочное написание кодов следующего вида:

 char s1='456gh'; //Скомпилируется. В лучшем случае с предупреждением

1	char s1='456gh'; //Скомпилируется. В лучшем случае с предупреждением

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

Поскольку тип char относится к целочисленным типам, компьютер видит переменные типа char как числа, то числа эти можно легко подсмотреть.

//Borland C++ 3.1       Узнаём код символа      Листинг #5
#include <iostream.h>

int main()
{
    char y = 'z';
    cout << y - 0;                      //Способ 1
    cout << '\n';
    cout << int(y) << '\n';                       //Способ 2
    cout << static_cast<int>(y) << '\n';          //Способ 3
}

//Borland C++ 3.1 Узнаём код символа Листинг #5

#include <iostream.h>

int main()

{

char y = 'z';

cout << y - 0; //Способ 1

cout << '\n';

cout << int(y) << '\n'; //Способ 2

cout << static_cast<int>(y) << '\n'; //Способ 3

}

В листинге #5 показано 3 способа получить числовое представление символьной переменной.

Подводим итоги, эта статья должна была научить вас следующему:

Сохранять символы в переменную типа char.
В С++ одинарные кавычки используются для символов, двойные для массивов символов.
Для символьных переменных массивы слишком велики.
Символьные переменные это обычные числа, ASCII коды, которые могут быть представлены людям в виде символов.
То, что мы видим числа как символы, следствие работы объекта cout
Числовое представление символьных типов легко получать с помощью несложных манипуляций

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

Моё описание непосредственно типа char в С++ на этом закончено. Не путайте кавычки.

//Borland C++ 3.1       Сохранение символа в char
//Листинг #6

#include <conio.h>
#include <iostream.h>
int main()
{
  clrscr(); //Очищаем экран
  char s1; //Объявляем переменную s1
  s1 = 'y'; //Присвоение переменной s1 значения
  cout << s1; //Выводим букву 'y' на экран
}

//Borland C++ 3.1 Сохранение символа в char

//Листинг #6

#include <conio.h>

#include <iostream.h>

int main()

{

clrscr(); //Очищаем экран

char s1; //Объявляем переменную s1

s1 = 'y'; //Присвоение переменной s1 значения

cout << s1; //Выводим букву 'y' на экран

}

Похожие темы:

Строки String в Borland C++ 3.1 для начинающих

С++ для начинающих Передача символьного массива в функцию

C++ для начинающих Символьный массив

Немного забегу вперёд, покажу кое-что.

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

//Си-строки     символьный массив       Листинг #7
int main(){
    char arr[255];  //Массив из 255 символов
}

//Си-строки символьный массив Листинг #7

int main(){

char arr[255]; //Массив из 255 символов

}

//Си-строки     указатель на константную строку       Листинг #8
int main(){
    char* arr;  //Указатель на массив символов
}

//Си-строки указатель на константную строку Листинг #8

int main(){

char* arr; //Указатель на массив символов

}

//Си-строки     указатель на символьную строку       Листинг #9
int main(){
    char* arr;  //Указатель на массив символов
}

//Си-строки указатель на символьную строку Листинг #9

int main(){

char* arr; //Указатель на массив символов

}

//Си-строки     указатель на константную символьную строку       Листинг #10
int main(){
    const char* arr;  //Указатель на массив символов
}

//Си-строки указатель на константную символьную строку Листинг #10

int main(){

const char* arr; //Указатель на массив символов

}

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

Рубрика: Базовые знания, level "HelloWorld", Переменные, Типы, Фундаментальные типы

Anonymous:

12.08.2012 в 3:38 дп

char s1; s1="y"; можно было так: char s1='у';

Автор сайта отвечает:
Да. Это проще и правильнее. Спасибо

Ответить

Алексей:

17.10.2012 в 3:13 пп

Спасибо, все понятно описано! Буду читать ваш блог

guest:

12.11.2012 в 6:00 дп

char *s1 = «y»;

Was:

05.01.2013 в 5:06 пп

#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1 = "y";
cout<< s1 << endl;
return 0; 
}

#include <iostream>

#include <string>

using namespace std;

string s1 = "y";

cout<< s1 << endl;

return 0;

Денис:

01.04.2013 в 7:07 пп

———
char s1 [100]; //Объявляем переменную s1
Почти равносилен тому, что мы объявили строку, состоящую из 101 символа.
Если не понимаете почему 101, а не 100 – лучше изучайте массивы
———

Что значит «почти»? В объявленном массиве 100 элементов, а не 101. «Лучше изучайте массивы» 🙂

Автор сайта отвечает:
Ошибся, когда писал. Что ж поделать,
Трудно что-то исправлять когда сотни тысяч глаз глаз видят страницу, читают её, учат по ней и только спустя годы кто-то говорит, что тут вот ошибка.

спасибо, что отметили ошибку.

Аноним:

13.01.2014 в 5:34 пп

)))

14

Ответить

Infinity:

05.01.2014 в 1:04 пп

Когда ты пишешь char s1=»y», то ты присваиваешь переменной типа символ строку! Так как двойные ковычки — это строка, это передача значание y и символа конца строки. Поэтому у тебя и не присваивалось значение.
А с * у тебя получилось, так как ты присвоил переменной типа чар первый элемент массива.
Правильно надо было присвоить переменной типа чар только символ, а для этого символ помещается в ОДИНАРНЫЕ кавычки.
s1=’y’;

Автор сайта отвечает:
именно так.
только один нюанс. В С++ тип char это обычные целые числа. Только в отличии от привычных целочисленных типов данных, он используется для представления символов. Т.е. также правильно как и с одинарными кавычками присваивать в переменную s целое число, которое соответствует нужному символу.

Максим говорит:
06.01.2014 в 6:57 пп

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

C++

char a='d';

1

char a='d';

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

Nik:

05.08.2015 в 3:52 пп

«…неполное очищение строки, а только частичное.» в конце статьи. Не, вроде, раздельно пишется в слове «неполное». и, кстати, «Максимуочень признателен…» — тут тоже, по-моему, что-то не так…)

Владимир:

16.10.2015 в 8:24 пп

Я не в чём не упрекаю автора. Просто как пользователь Linux таким же пользователям хочу добавить:

Если вы пишете программу в Linux, то попытка присвоить переменной char символ кириллицы — вызовет ошибку компилятора. Так как символ кириллицы в данной операционной системе есть только в кодировке UTF8 и занимает 2 байта. Которые не смогут влезть в 1 байт отведённый компилятором под переменную типа char.

В своё время, когда только начинал программировать, я долго не мог найти причину этой ошибки. Так что имейте в виду.

Сергей:

24.01.2016 в 2:53 пп

Здравствуйте. Поясните пожалуйста, почему строка

char ch=1;

1	char ch=1;

присваивает в переменную аски-код единицы, а

char ch; ch = 0;

1	char ch; ch = 0;

обнуляет символьную переменную, а не прописывает аски-код нуля?

admin:

25.01.2016 в 3:35 пп

Присваивает, просто объект cout проявляет инициативу и выводит значение переменной как тип char. Поэтому 0 превращается в признак конца строки: пустой символ.
Если первый же символ является признаком конца строки, то строки как бы и нет.

Если на экран выводить тип переменной в принудительной форме к int, то будет видно, что всё верно.

#include <iostream>
using namespace std;

int main()
{
   char x = 0;

   cout << "as str: " << x; //В строке есть только признак конца строки
   cout << '\n';
   cout << "as int: " << (int)x;  //Принудительно

   cout << "\n\n";
   int y = x; //в y пришло 0
   cout << "y = " << y;

}

char x = 0;

cout << "as str: " << x; //В строке есть только признак конца строки

cout << "as int: " << (int)x; //Принудительно

cout << "\n\n";

int y = x; //в y пришло 0

cout << "y = " << y;

ответ был исправлен намного позже, чем был задан вопрос

Аноним:

25.04.2017 в 2:38 дп

Здравствуйте!У меня возникла проблема при чтении текста.

 cin << t;

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

25.04.2017 в 11:35 дп

//для одного символа
char ch;
cin >> ch; //ввод и запись символа в ch
cout << ch;

//для одного символа

char ch;

cin >> ch; //ввод и запись символа в ch

cout << ch;

Для строки:

#include <iostream>
using namespace std;

int main()
{
   char ch[255];

   cin.getline(ch,10); //цифра не больше, чем вмещает массив и не меньше, чем нужно строке символов
                       //включая символ-признак конца строки
   cout << ch;
}

char ch[255];

cin.getline(ch,10); //цифра не больше, чем вмещает массив и не меньше, чем нужно строке символов

//включая символ-признак конца строки

#include <string>
#include <iostream>
using namespace std;

int main()
{
   string S;

   getline(cin,S);
   cout << S;
}

string S;

getline(cin,S);

cout << S;

delphin:

24.08.2017 в 1:18 пп

char ch=‘y’;
cout<<int(ch);

Так правильно)

Kseniya:

14.05.2019 в 10:23 дп

Спасибо, для начинающих — самое то. Без заумной теории и на «человеческом» языке.

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

Александр к записи Хороший стиль программирования
Аноним к записи Список тем сайта
Аноним к записи Список тем сайта

Переменная типа char в C++ для начинающих и как с ней работать

15 комментариев на «“Переменная типа char в C++ для начинающих и как с ней работать”»

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

Поиск

Последние темы

Случайная книга в электронном формате

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

Мета