C++ — помогите в C++; при любом вводе выводит что y = 0


Содержание

Задачи по C++. Вычислить значение функции

Условие задачи : Требуется написать программу, вычисляющую значение функции у = f(x).

Сложность : легкая .

Для того чтобы нам решить подобную задачу нужно будет воспользоваться обычным условием if else.

К примеру нам надо решить вот такую систему функции :

у = x – 2, если x > 0,
y = 0, если x = 0,
y = |x|, если x 0
если оно не выполняется , т.е. наше число x меньше 0 , то оно уже подставляется в другое условие и так далее.

Урок 2 — Ввод/вывод, операции над числами

В этой теме 0 ответов, 1 участник, последнее обновление Васильев Владимир Сергеевич 2 года/лет, 7 мес. назад.

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

1 Потоковый ввод/вывод

В файле iostream.h находятся глобальные объекты std::cin и std::cout , позволяющие вводить данные с клавиатуры и выводить их на экран. Мы подключаем этот файл командой:
#include

Эти объекты называются потоками ввода/вывода. В дальнейших уроках мы узнаем и о других разновидностях таких потоков. Потоковый ввод/вывод осуществляется операциями >> и соответственно. Использовать их можно следующим образом:

В этой программе создается 3 переменных целого типа данных ( int ), в конце урока приведена более подробная информация об этом и других стандартных типах. Тут, как и в hello world использолся вызов функции std::cin.get() для задержки закрытия окна. На самом деле эта функция ( get ) ожидает ввода символа пользователем.

Также, в этом примере вы должны заметить комментарии к коду. Комментарием считается часть строки, расположенная правее двух слешей , а тажке текст (возможно многострочный), расположенный между символами /* и */ . Комментарии удаляются во время работы препроцессора (если забыли что это такое — освежите память) и, следовательно, не влияют на результаты компиляции. Используются комментарии только в качестве «подсказок» программисту.

Объект std::cin является потоком ввода, к нему можно применять оператор >> для получения значений переменных с клавиатуры:

Теперь значения переменных задаются не программистом, а пользователем (в процессе использования программы).

С помощью объекта cin и операции >> можно присвоить значение любой переменной. Например, если переменная x описана как целочисленная, то команда cin>>x; означает, что в переменную x будет записано некое целое число, введенное с клавиатуры. Если необходимо ввести несколько переменных, то можно написать:
cin >> x >> y >> z; .

2 Основные операции над числами

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

Директива using namespace std; сообщает компилятору, что в этом месте вы используете имена из пространства имен std , за счет нее вы, в частности, можете писать cout или cin вместо std::cout и std::cin . Тему пространств имен мы подробно изучим в следующих уроках.

Поиграйтесь с исходными числами, обратите внимание, что в результате деления вы получаете целое число (округляется вниз — как при выполнении операции div в Паскале). Очень часто вам будет пригождаться операция получения остатка от деления ( a%b ) — разберитесь с тем, что она возвращает.

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

Помимо целых чисел, компьютер может обрабатывать дробные — замените тип int в нашей программе на float или double , при попытке собрать программу вы получите ошибки, т.к. не все используемые тут операторы могут применяться к дробным числам. Изучите сообщения об ошибках — вам нужно научиться их читать. Запустите следующую программу:

Обратите внимание, что теперь даже если на вход будут поданы целые числа — результат операции деления будет дробным. Различия между типами данных double и float в данный момент для нас несущественны — достаточно помнить, что float обычно занимает 4 байта, а double — 8, за счет этого при вычислениях над переменными double мы можем получить более высокую точность и диапазон значений (см. справочный материал в конце урока).

Теперь рассмотрим изученное на примере более сложной задачи (наконец, заставим наш компьютер посчитать что-нибудь полезное):

Известны плотность p , высота h и радиус основания R цилиндрического слитка.
Найти объем V , массу m и площадь S основания слитка.

Составим текст программы, учитывая что:
$$S = \pi \cdot R \cdot R, \\
V = S \cdot h,\\
m = p \cdot V.$$

Результаты работы программы:

Исследуя эту программу, обратите внимание на:

  1. описание констант с помощью ключевого слова const . Константе значение присваивается лишь один раз, если вы попробуете сделать это еще раз — программа не скомпилируется. Очень хорошая практика — явно указывать константность везде, где это возможно. Это с одной стороны защитит вас от ошибок в дальнейшем (при попытке изменить константу вы сразу получите ошибку), а с другой — позволит генерировать более оптимальный код компилятору.
  2. в конце программы мы написали cin.get() дважды. Дело в том, что:
    • функция get извлекает из потока cin один символ. Символы попадут в поток после нажатия пользователем кнопки Enter;
    • оператор >> считывает из потока слово и, в нашем случае, преобразует его в число. Исследуя программы, вы должны были заметить, что если ввести в одной строке несколько чисел — то «сработают» сразу несколько последовательных операторов ввода. Мы пользовались этим, например, при исследовании математических операторов;
    • считав первое слово с потока — оператор >> не «трогает» остальные символы. В результате, в потоке остается символ-разделитель — в нашем случае — символ перевода строки (соответствующий клавише Enter). Этот символ и будет считан первым вызовом функции get() ;
    • таким образом, если оставить только один вызов get() программа отобразит на экран результаты вычислений и сразу завершится. Второй вызов get() ожидает еще одного нажатия клавиши Enter пользователем;
    • вам нужно помнить об этом всякий раз, когда вы используете get после оператора >> .
  3. в этой программе не так легко разобраться, как хотелось бы и очень легко запутаться. Проблема заключается в «плохих» именах переменных. По мере усложнения ваших программ эта проблема станет более очевидной. Заведите правило — давать переменным имена, которые отражают суть. Более подробно про это можно прочитать в статье «Теория чистого кода. Стиль кодирования«. Попробуйте переписать эту программу, используя более понятные имена.

3 Справочный материал

3.1 Переменные и типы данных

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

Для решения задачи в любой программе выполняется обработка каких-либо данных. К основным типам данных языка C++ относят:

  • char — символьный;
  • int — целый;
  • float — дробное число с плавающей точкой;
  • double — дробное число двойной точности;
  • bool — логический.
  • void — неполный тип и спецификатор типа. Множество значений этого типа пусто (поэтому его нет в таблице ниже). Он используется для определения функций, которые не возвращают значения, а также как базовый тип для указателей. Вы не можете создать переменную этого типа, позже станет понятно как им пользоваться.

Для формирования других типов данных используют основные и так называемые спецификаторы:


  • short — короткий;
  • long — длинный;
  • signed — знаковый;
  • unsigned — беззнаковый.
  • const — константа.

В таблице приведена справочная информация о различных комбинациях типов данных с учетом спецификаторов для операционной системы Windows:

Имя типа Размер (в байтах) Диапазон значений
int (signed int) 4 От -2 147 483 648 до 2 147 483 647
unsigned int 4 От 0 до 4 294 967 295
bool 1 false или true
char (unsigned char) 1 -128 до 127 знаков по умолчанию
signed char 1 От -128 до 127
unsigned char 1 От 0 до 255
short (signed short) 2 От -32 768 до 32 767
unsigned short 2 От 0 до 65 535
long (signed long) 4 От -2 147 483 648 до 2 147 483 647
unsigned long 4 От 0 до 4 294 967 295
long long (signed long long) 8 От -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
unsigned long long 8 От 0 до 18 446 744 073 709 551 615
float 4 3,4E +/- 38 (7 знаков)
double (long double) 8 1,7E +/- 308 (15 знаков)
wchar_t 2 От 0 до 65 535

Тип char предназначен для хранения символов, обрабатывать строки (состоящие из символов) мы научимся в следующих уроках, сейчас нужно знать, что внутри компьютера символы хранятся в виде целых чисел в небольшом диапазоне. Преобразование символов в числа и назад производится на основе кодовых таблиц, которые можно менять (в зависимости от языка — русский, английский, китайский, …). Строка записывается в двойных кавычках («hello world»), а одиночный символ — в одинарных (‘a’).

Тип wchar_t также используется для хранение символов, однако занимает 2 байта (в Unix — 4 байта) и хранит данные в формате Юникода.

Переменная типа bool может принимать только два значения true (истина) или fasle (ложь), тем не менее, в памяти занимает не 1 бит, а 1 байт. Любое значение, не равное нулю, интерпретируется как true .

3.2 Битовые операции

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

Ниже показано как выполняется операция логического ИЛИ для такого фрагмента кода:

Подобным образом работают операции — И ( a & b ), исключающее ИЛИ ( a ^ b ). Операции и >> , примененные для чисел, осуществляют битовый сдвиг двоичного представления числа влево и вправо на заданное число разрядов.

$$
Ниже: 20_<10>\;-\;число\;20\;в\;десятичной\;системе\;счисления, \\
10001_<2>\;-\;число\;20\;в\;двоичной\;системе\;счисления. \\
20_<10>\;|\;17_ <10>= 10001_2\;|\;10100_2 = 10101_2 = 21_<10>. \\
20_<10>\;\&\;17_ <10>= 10001_2\;\&\;10100_2 = 10000_2 = 16_<10>. \\
20_<10>\;\hat<>\;17_ <10>= 10001_2\;\hat<>\;10100_2 = 00101_2 = 5_<10>. \\
47_ <10>> 2 = 101111_2 >> 2 = 1011_2 = 11_<10>.
$$

3.3 Приведение типов

В C++ различают два вида преобразования типов данных: явное и неявное.

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

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

В этом примере при присваивании выполнится неявное приведение переменной типа float к типу int . В результате работы программы на экран будет выведено число 123 .

Явное преобразование в отличие от неявного осуществляется программистом. Записать это можно следующим образом:
b = (int) a;
или
b = int(a);

Тут мы явно указываем, что переменной b нужно присвоить значение a, приведенное к типу int .

Приведенные ниже конструкции могут встретиться вам при просмотре чужого исходного кода, вам нужно иметь представление о них, при необходимости — более подробно прочитайте в статье «Явное приведение типов в C++«.

В С++ определены следующие операторы:

    static_cast<> () — осуществляет преобразование связанных типов данных. Этот оператор приводит типы по обычным правилам, что может потребоваться в случае, когда компилятор не выполняет автоматическое преобразование. Синтаксис будет выглядеть так:

Тип static_cast (объект);

С помощью static_cast нельзя убрать константность у переменной, но это по силам следующему оператору.

const_cast<> () — применяется только тогда, когда нужно снять константность у объекта. Синтаксис будет выглядеть следующим образом:

Тип const_cast (объект);
reinterpret_cast<> () — применяется для преобразования указателей разных типов, целых к указателю и наоборот. Если вы увидели новое слово «указатель» — не пугайтесь! это тоже тип данных, но работать с ним Мы будем не скоро. Синтаксис тут такой же как, у ранее рассмотренных операторах:

Тип reinterpret_cast (объект);

  • dynamic_cast<> () — используется для динамического преобразования типов, реализует приведение указателей или ссылок. Синтаксис:
    Тип dynamic_cast (объект);
  • 3.4 Составное присваивание, инкремент/декремент

    В ваших программах часто нужно выполнить что-то типа
    a = a+b;
    вместо такой конструкции можно использовать специальный вид оператора:
    a += b;

    Еще чаще в программах нужно увеличивать или уменьшать значение переменной ровно на единицу:

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

    В этом примере оба вида оператора применяются к переменной a и оба они приводят к увеличению значения переменной на единицу. Однако, постфиксная форма возвращает старое значение пеерменной (до инкремента), а префиксная — новое значение. Поэтому на экран будет выведено:

    Аналогично работает постфиксный и префиксный декремент (оператор — ).


    Помощь C++

    Помогите разобраться в что конкретно делают вот эти части кода.

    #define max_len 300

    using namespace std;

    Найдены возможные дубликаты

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

    Читайте ниже, я отвечал, кто я такой, а про гастарбайтера и обидно было, я вчера только начал учить ваш хваленый «Цу-плас-плас».

    Тогда лучше начни с чего-нибудь попроще.

    думаю, тебе не стоит лезть в C++, есть более простые и широкоприменяемые ЯП

    Делает «Введiть речення» или «Отримане речення:»

    1) для задания в тексте программы символов типа char используются одинарные кавычки.

    2) элемент типа char не может быть пустым. Может быть равен #0, не никак не пустым. Это не строка, у которой длина может быть нулевой, а конкретный символ.

    @ARMAGEDONS , в цикле выводятся символы следующие за пробелами. Если за пробелом следуют двойные кавычки, то выводится следующий за ними символ.

    должно быть приведение char к string

    Кому это оно должно?

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

    Огромное спасибо, удачи вам )

    Из — за того что тут есть и работа со стандартной библиотекой и работа с динамически выделенной памятью, просто так это не рассказать. Кури любой мануал по С++ и глав за 10 ты сможешь понять этот код в полной мере.

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

    Спасибо за форумы, а вообще что по рекомендуете читать ?

    Прата хороший учебник написал. Многие преподаватели советуют Страуструпа, но мне он не зашёл. Для ООП Лафоре хорошо пишет.

    я вообще 1сник, но догадаться не сложно

    char* str = new char[max_len]; — выделяет место под массив чаров

    Ввод и вывод данных средствами языка C

    В системе ввода-вывода в Си для программ поддерживается единый интерфейс, не зависящий от того, к какому конкретному устройству осуществляется доступ. То есть в Си между программой и устройством находится нечто более общее, чем само устройство. Такое обобщенное устройство ввода или вывода (устройство более высокого уровня абстракции) называется потоком. В то же время конкретное устройство называется файлом. Наша задача — понять, каким обрзом происходит взаимодействие потоков и файлов.
    Файловая система Си предназначена для работы с разными устройствами, в том числе с терминалами, дисководами и накопителями. Даже, если какое-то устройство очень сильно отличается от других устройств, буферизованная файловая система все равно представит его в виде логического устройства, которое называется потоком. Все потоки ведут себя похожим образом. И так как они в основном не зависят от физических устройств, то та же функция, которая выполняет запись в дисковый файл, может ту же операцию выполнить и на другом устройстве. Например, на консоли. Потоки бывают двух видов: текстовые и двоичные.
    В языке Си файлом может быть все, что угодно, начиная в дискового файла и заканчивая терминалом или принтером. Поток связывают с определенным файлом, выполняя обязательную операцию открытия. Как только файл открыт, можно проводить обмен информацией между ним и программой.
    Но не у всех файлов одинаковые возможности. Например, к дисковому файлу прямой доступ возможен, в то время как к некоторым принтерам — он не возможен. Таким образом, вы видите, что напрашивается определенный вывод, являющийся принципом системы ввода-вывода языка Си: все потоки одинаковы, а файлы — нет!
    Если файл может поддерживать запросы на местоположение (указатель текущей позиции), то при открытии такого файла указатель текущей позиции в файле устанавливается в начало файла. При чтении каждого символа из файла (или записи в файл) указатель текущей позиции увеличивается. Тем самым обеспечивается продвижение по файлу.
    Файл отсоединяется от определенного потока (то есть разрывается связь между файлом и потоком) с помощью операции закрытия файла. При закрытии файла, открытого с целью вывода, содержимое (если оно, конечно, есть) связанного с ним потока записывается на внешнее устройство. Этот процесс обычно называют дозаписью потока. При этом гарантируется, что никакая информация случайно не останется в буфере диска.
    Если программа завершает работу нормально, то есть либо main() возвращает управление операционной системе, либо выход происходит через exit(), то все файлы закрываются автоматически.
    В случае же аварийного завершения работы программы, например, в случа краха или завершения путем вызова abort(), файлы не закрываются.
    У каждого потока, связанного с файлом, имеется управляющая структура, содержащая информацию о файле. Она имеет тип FILE. Блок управления файлом — это небольшой блок памяти, временно выделенный операционной системой для хранения информации о файле, который был открыт для использования. Блок управления файлом обычно содержит информацию об идентификаторе файла, его расположении на диске и указателе текущей позиции в файле.
    Для выполнения всех операций ввода-вывода следует использовать только понятия потоков и применять всего лишь одну файловую систему. Ввод или вывод от каждого устройства автоматически преобразуется системой в легко управлемый поток. И это является достижением языка Си.
    Таковы основополагающие замечания относительно существования различных потоков информации и связанных с ними файлов.
    Файловая система языка Си состоит из нескольких взаимосвязанных между собой функций. Для их работы в Си требуется заголовочный файл и такой же аналогичный ему заголовочный файл требуется для работы в С++.
    Ниже приведена таблица основных (часто используемых) функций файловой системы языка Си.

    Имя Что делает эта функция Имя Что делает эта функция
    fopen() Открывает файл feof() Возвращает значение true (истина), если достигнут конец файла
    fclose() Закрывает файл ferror() Возвращает значение true (истина), если произошла ошибка
    putc() Записывает символ в файл remove() Стирает файл
    fputc() То же, что и putc() fflush() Дозапись потока в файл
    getc() Читает символ из файла rewind() Устанавливает указатель текущей позиции в начало файла
    fgetc() То же, что и getc() ftell() Возвращает текущее значение указателя текущей позиции в файле
    fgets() Читает строку из файла fprintf() Для файла то же, что printf() для консоли
    fputs() Записывает строку в файл fscanf() Для файла то же, что scanf() для консоли
    fseek() Устанавливает указатель текущей позиции на определенный байт файла

    Заголовок представляет прототипы функций ввода-вывода в Си и определяет следующие три типа: size_t, fpos_t и FILE. Первые два: size_t, fpos_t представляют собой разновидности такого типа, как целое без знака. Отдельно рассмотрим третий тип: FILE.
    Указатель файла — это то, что соединяет в единое целое всю систему ввода-вывода языка Си. Указатель файла — это указатель на структуру типа FILE. Он указывает на структуру, содержащую различные сведения о файле, например, его имя, статус, и указатель текущей позиции в начало файла. В сущности указатель файла определяет конкретный файл и используется соответствующим потоком при выполнении функции ввода-вывода.
    Чтобы выполнять в файлах операции чтения и записи, программы должны использовать указатели соответствующих файлов. Чтобы объвить переменную-указатель файла необходимо использовать следующий оператор:
    FILE *fp;
    Функция fopen() открывает поток и связывает с этим потоком файл. Затем она возвращает указатель этого файла. Прототип функции имеет вид:
    FILE *fopen(const char *имя_файла, const char *режим);
    Здесь имя_файла — это указатель на строку символов, представляющую собой допустимое имя файла, в которое может входить спецификация файла (включает обозначение логического устройства, путь к файлу и собственно имя файла).
    Режим — определяет, каким образом файл будет открыт. Ниже в таблице показаны допустимые значения режимов.

    Режим Что обозначает данный режим
    r Открыть текстовый файл для чтения
    w Создать текстовый файл для записи
    a Добавить в конец текстового файла
    wb Создать двоичный файл для записи
    rb Открыть двоичный файл для чтения
    ab Добавить в конец двоичного файла
    r+ Открыть текстовый файл для чтения/записи
    w+ Создать текстовый файл для чтения/записи
    a+ Добавить в конец текстового файла или создать текстовый файл для чтения/записи
    r+b Открыть двоичный файл для чтения/записи
    w+b Создать двоичный файл для чтения/записи
    a+b Добавить в конец двоичного файла или создать двоичный файл для чтения/записи

    Приведем фрагмент программы, в котором используется функция fopen() для открытия файла по имени TEST.
    FILE *fp;
    fp = fopen(«test», «w»);
    Следует сразу же указать на недостаточность такого кода в программе. Хотя приведенный код технически правильный, но его обычно пишут немного по-другому.
    FILE *fp;
    if ((fp = fopen(«test», «w»)==NUL)
    <
    printf(«Ошибка при открытии файла.\n\r»)»
    exit(1);
    >

    Рис. 1
    Этот метод помогает при открытии файла обнаружить любую ошибку.
    Например, защиту от записи или полный диск. Причем, обнаружить еще до того, как программа попытается в этот файл что-то записать. Поэтому всегда нужно вначале получить подтверждение, что функция fopen() выполнилась успешно, и лишь затем выполнять c файлом другие операции. Ниже на рисунке 1 приведена небольшую часть программы, которая. подтверждает или не подтверждает открытие файла. Результаты работы указанной программы приведены на рисунке 2.

    Потоковый ввод-вывод
    На уровне потокового ввода-вывода обмен данными производится побайтно. Такой ввод-вывод возможен как для собственно устройств побайтового обмена (печатающее устройство, дисплей), так и для файлов на диске, хотя устройства внешней памяти, строго говоря, являются устройствами поблочного обмена, т.е. за одно обращение к устройству производится считывание или запись фиксированной порции данных. Чаще всего минимальной порцией данных, участвующей в обмене с внешней памятью, являются блоки в 512 байт или 1024 байта. При вводе с диска (при чтении из файла) данные помещаются в буфер операционной системы, а затем побайтно или определенными порциями передаются программе пользователя. При выводе данных в файл они накапливаются в буфере, а при заполнении буфера записываются в виде единого блока на диск за одно обращение к последнему. Буферы операционной системы реализуются в виде участков основной памяти. Поэтому пересылки между буферами ввода-вывода и выполняемой программой происходят достаточно быстро в отличие от реальных обменов с физическими устройствами.
    Функции библиотеки ввода-вывода языка Си, поддерживающие обмен данными с файлами на уровне потока, позволяют обрабатывать данные различных размеров и форматов, обеспечивая при этом буферизованный ввод и вывод. Таким образом, поток — это файл вместе с предоставляемыми средствами буферизации.
    При работе с потоком можно производить следующие действия:
    · открывать и закрывать потоки (связывать указатели на потоки с конкретными файлами);
    · вводить и выводить: символ, строку, форматированные данные, порцию данных произвольной длины;
    · анализировать ошибки потокового ввода-вывода и условие достижения конца потока (конца файла);
    · управлять буферизацией потока и размером буфера;
    · получать и устанавливать указатель (индикатор) текущей позиции
    При открытии потока могут возникнуть следующие ошибки: указанный файл, связанный с потоком, не найден (для режима «чтение»); диск заполнен или диск защищен от записи и т.п. Необходимо также отметить, что при выполнении функции fopen() происходит выделение динамической памяти. При её отсутствии устанавливается признак ошибки «Not enough memory» (недостаточно памяти). В перечисленных случаях указатель на поток приобретает значение NULL. Заметим, что указатель на поток в любом режиме, отличном от аварийного никогда не бывает равным NULL.
    Приведем типичную последовательность операторов, которая используется при открытии файла, связанного с потоком:
    if ((fp = fopen(«t.txt»,»w»)) == NULL)
    perror(«ошибка при открытии файла t.txt \n»);
    exit(0);
    >
    Где NULL — нулевой указатель, определенный в файле stdio.h.
    Открытые на диске файлы после окончания работы с ними рекомендуется закрыть явно. Для этого используется библиотечная функция
    int fclose (указатель_на_поток);
    Открытый файл можно открыть повторно (например, для изменения режима работы с ним) только после того, как файл будет закрыт с помощью функции fclose().
    Когда программа начинает выполняться, автоматически открываются пять потоков, из которых основными являются:
    · стандартный поток ввода (на него ссылаются, используя предопределенный указатель на поток stdin);
    · стандартный поток вывода (stdout);
    · стандартный поток вывода сообщений об ошибках (stderr).
    По умолчанию стандартному потоку ввода stdin ставится в соответствие клавиатура, а потокам stdout и stderr соответствует экран дисплея.
    Одним из наиболее эффективных способов осуществления ввода-вывода одного символа является использование библиотечных функций getchar( ) и putchar(). Прототипы этих функций имеют следующий вид:
    int getchar(void);
    int putchar(int c);
    Функция getchаr( ) осуществляет ввод одного символа. При обращении она возвращает в вызвавшую ее функцию один введенный символ.
    Функция putchar( ) выводит в стандартный поток один символ, при этом также возвращает в вызвавшую ее функцию только что выведенный символ.
    Обратите внимание на то, что функция getchar( ) вводит очередной байт информации (символ) в виде значения типа int. Это сделано для того, чтобы гарантировать успешность распознавания ситуации «достигнут конец файла». Дело в том, что при чтении из файла с помощью функции getchar() может быть достигнут конец файла. В этом случае операционная система в ответ на попытку чтения символа передает функции getchar() значение EOF (End of File). Константа EOF определена в заголовочном файле stdio.h и в разных операционных системах имеет значение 0 или -1. Таким образом, функция getchar() должна иметь возможность прочитать из входного потока не только символ, но и целое значение. Именно с этой целью функция getchar( ) всегда возвращает значение типа int.
    В случае ошибки при вводе функция getchar() также возвращает EOF.
    При наборе текста на клавиатуре коды символов записываются во внутренний буфер операционной системы, Одновременно они отображаются (для визуального контроля) на экране дисплея. Набранные на клавиатуре символы можно редактировать (удалять и набирать новые). Фактический перенос символов из внутреннего буфера в программу происходит при нажатии клавиши . При этом код клавиши также заносится во внутренний буфер. Таким образом, при нажатии на (Клавишу ‘А’ и клавишу (завершение ввода) во внутреннем буфере оказываются: код символа ‘А’ и код клавиши . ) Об этом необходимо помнить, если вы рассчитываете на ввод функцией getchar() одиночного символа.
    Приведём в пример программу копирования из стандартного ввода в стандартный вывод:
    #include
    int main()
    <
    int c;
    while ((c=getchar())!=EOF)
    Putchar(c);
    return 0;
    >
    Для завершения приведенной выше программы копирования необходимо ввести с клавиатуры сигнал прерывания Ctrl+C.
    Одной из наиболее популярных операций ввода-вывода является операция ввода-вывода строки символов. В библиотеку языка Си для обмена данными через Стандартные потоки ввода-вывода включены функции ввода-вывода строк gets() и puts(), которые удобно использовать при создании диалоговых систем. Прототипы этих функций имеют следующий вид:
    char * gets (char * s); /* Функция ввода */
    int puts (char * s); /* Функция вывода */
    Обе функции имеют только один аргумент — указатель s на массив символов. Бели строка прочитана удачно, функция gets( ) возвращает адрес того массива s, в который производился ввод строки. Если произошла ошибка, то возвращается NULL.
    Функция puts() в случае успешного завершения возвращает последний выведенный символ, который всегда является символом ‘\n’. Если произошла ошибка, то возвращается EOF.

    32) Ввод и вывод данных средствами языка C++.

    В языке С имеется весьма развитая библиотека функций ввода-вывода. Однако в самом языке отсутствуют какие-либо предопределенные файловые структуры. Все данные обрабатываются как последовательность байт. Имеется три основных типа функций: потоковые, работающие с консолью и портами ввода-вывода и низкоуровневые.
    Потоковые функции.
    В потоковых функциях файлы данных рассматриваются как поток отдельных символов.
    Когда программа открывает файл для ввода вывода при помощи потоковых функций, то открытый файл связывается с некоторой переменной типа FILE (определенной в stdio.h), содержащей базовую информацию об этом файле. После открытия потока с помощью функции fopen возвращается указатель на эту переменную. Этот указатель используется для ссылки к файлу при всех последующих операциях ввода-вывода и называется указателем потока.
    Все потоковые функции обеспечивают буферизованный, форматированный или неформатированный ввод/вывод. Буферизация потока разгружает приложение. Однако следует иметь ввиду, что при аварийном завершении программы содержимое буферов вывода может быть потеряно.
    Аналогичным образом выглядят функции, работающие с консолью и портами. Они позволяют читать и писать на терминал или в порт ввода/вывода (например в порт принтера). Функции портов ввода/вывода выполняют простое побайтное считывание или запись. Функции ввода/вывода на консоль обеспечивают несколько дополнительных возможностей, например можно определить момент, когда будет введен символ с консоли и т.п.
    Для использования потоковых функций в программу должен быть включен заголовочный файл stdio.h. В нем содержатся описания прототипов функций ввода/вывода, а также — описания ряда констант. Константа EOF определяется как значение, возвращаемое при обнаружении конца файла, BUFSIZE — размер буферов потока, тип FILE определяет структуру, используемую для получения информации о потоке.
    Поток открывается с помощью функций fopen(), fdopen() или freopen(). В момент открытия задаются режим файла и способ доступа. Эти функции возвращают указатель на переменную типа FILE, например
    FILE *file1;
    file1=fopen(“input.dat”,”r”);
    открывает файл input.dat для чтения. Переменная file1 получает указатель на поток.
    Возможные типы доступа:
    “a” – запись в режиме добавления в конец файла,
    ”a+” –тоже, что и “a”, но возможно и чтение,
    ”r” – только для чтения,
    ”r+” – для чтения и записи,
    ”w” – открывается пустой файл для записи,
    ”w+” – открывается пустой файл для записи и чтения.
    Когда начинается выполнение приложения автоматически открывается следующие потоки: стандартное устройство ввода stdin, стандартное устройство вывода stdout, устройство сообщений об ошибках stderr, устройство печати stdprn и стандартное дополнительное устройство stdaux. Эти файловые указатели можно использовать во всех функциях ввода/вывода в качестве указателя на поток. Некоторые функции автоматически используют указатели на поток, например getchar() и putchar() используют stdin и stdout соответственно.
    Для закрытия потоков используются функции fclose() и fcloseall(). Если программа не закрывает поток явно, то он закрывается автоматически по ее завершению.
    Для перемещения по файлу можно использовать функции fseek(), ftell() и rewind().
    Низкоуровневый ввод и вывод.
    Функции низкоуровневого ввода-вывода не выполняю никакой буферизации и форматирования. Они непосредственно обращаются к средствам ввода/вывода операционной системы.
    При открытии файла на этом уровне возвращается описатель файла (file handle), представляющий собой целое число, используемое затем для обращения к этому файлу при дальнейших операциях. Для открытия используется функция open(), для закрытия – функция close().
    Функция read() читает данные в указанный массив, а write() – выводит данные из массива в файл, lseek() – используется для перемещения по файлу.
    Низкоуровневые функции не требуют включения заголовочного файла stdio.h, вместо него используется файл io.h.
    Низкоуровневая система ввода-вывода не вошла в стандарт ANSI C, поэтому ее не рекомендуют для дальнейшего использования.
    Ввод и вывод символов, строк, слов.
    Наиболее общими функциями являются те, которые работают с отдельными символами. Функция getc() вводит один символ из указанного файлового потока в переменную типа int:

    int ic;
    ic=getc(stdin);

    Вводится один символ из потока stdin.
    Функция putc() передает один символ в указанный файловый поток:

    Для стандартных потоков stdin и stdout можно использовать функции getchar() и putchar() соответственно:

    int ic;
    ic=getchar();
    putchar(ic);

    Функции getch() и putch() являются низкоуровневыми функциями. Обычно функция getch() используется для перехвата символа, введенного с клавиатуры сразу после его нажатия. Нажатия клавиши “Enter” не требуется.
    Для ввода/вывода текстовых строк можно использовать функции gets(), fgets(), puts(), fputs(). Функция fgets() имеет вид:
    fgets(имя_массива, размер_массива, указатель_на_поток);
    Она считывает символы в указанный массив и добавляет в конце null-символ. Считывание производится до заполнения массива, или до достижения конца файла. Символ перевода строки переписывается в массив.
    Для ввода и вывода целых чисел можно использовать функции getw() и putw(). Они работают с двоичными файлами.
    Форматированный ввод и вывод.
    Богатый ассортимент средств управления форматом позволяет легко создавать таблицы, графики или отчеты. Функциями, выполняющими этот вывод являются printf() — для стандартного потока вывода stdout, и fprintf() – для любого потока. Функция fprintf() имеет вид:
    fprintf(поток_вывода, “формат”, перем_1, перем_2,…);
    Работает она аналогично printf() и выводит данные в указанный поток вывода.
    Для форматированного ввода используются функции scanf() и fscanf().
    Для преобразования текстовой строки можно использовать sscanf(). Она работает аналогично fscanf(), но данные берет из сроки, а не из файла.
    Потоки cin, cout, cerr.
    В языке С++ имеется другая библиотека ввода/вывода, определяемая заголовочным файлом iostream.h. Ввод/вывод в ней определяется набором специальных классов. Аналогами потоков stdin, stdout и stderr являются cin, cout и cerr. Они открываются автоматически при запуске программы.
    Операции выделения >> и вставки > выделяет данные из входного потока и помещает в указанные переменные, а операция >ivalue>>dvalue>>cvalue;


    Аналогично для вывода:

    printf(“Integer:%d double: %lf”,ivalue,dvalue);
    cout
    #include
    using namespace std;

    int main()
    <
    int num[10];

    for(int i=0; i
    #include
    #include
    using namespace std;

    int main()
    <
    int num[10];
    int i, j, k;
    int size = 10;

    // Меняем элементы местами.
    i = num[k-1];
    num[k-1] = num[k];
    num[k] = i;
    >
    >
    >
    // Конец сортировки.

    // Отображаем отсортированный массив.
    cout
    #include
    using namespace std;

    Урок №11. cout, cin и endl

    Обновл. 23 Июл 2020 |

    В этом уроке мы рассмотрим такие объекты, как cout, endl и cin.

    std::cout

    Как мы уже говорили в предыдущих уроках, объект std::cout (который находится в библиотеке iostream) используется для вывода данных на экран (в консольное окно). В качестве напоминания, вот наша программа «Hello, world!»:

    Для вывода нескольких предложений на одной строке оператор вывода #include

    А какой результат выполнения следующей программы?

    Возможно, вы удивитесь, но:

    Hi!My name is Anton.

    std::endl

    Если текст нужно вывести раздельно (на нескольких строках) – используйте std::endl. При использовании с std::cout, std::endl вставляет символ новой строки. Таким образом, мы перемещаемся к началу следующей строки. Например:

    Hi!
    My name is Anton.

    std::cin

    std::cin является противоположностью std::cout. В то время как std::cout выводит данные в консоль с помощью оператора вывода >. Используя std::cin мы можем получать и обрабатывать пользовательский ввод.

    Попробуйте скомпилировать и запустить эту программу. При запуске вы увидите Enter a number: , затем программа будет ждать, пока вы введёте число. Как только вы это сделаете и нажмёте Enter, программа выведет You entered , а затем ваше число.

    Например (я ввёл 7 ):

    Enter a number: 7
    You entered 7

    Это самый простой способ получения данных от пользователя. Мы будем его использовать в дальнейших примерах.

    Если ваше окно закрывается сразу после ввода числа — смотрите Урок №7 (там есть решение этой проблемы).

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

    std::cin, std::cout, >

    Новички часто путают std::cin, std::cout, >. Вот простые способы запомнить их различия:

    std::cin и std::cout всегда находятся в левой стороне стейтмента;

    std::cout используется для вывода значения (cOUT = вывод);

    std::cin используется для получения значения (cIN = ввод);

    оператор вывода std::cout (значение 7 перемещается в консоль);

    оператор ввода >> используется с std::cin и показывает направление, в котором данные движутся из консоли в переменную. std::cin >> a; (значение из консоли перемещается в переменную a ).

    С++ для начинающих

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

    В C++ самой первой всегда выполняется функция main(), а остальные функции выполняются после. Чтобы функция сработала нужно в нее передать данные для обработки. Такие данные передают из основной программы и из других функций.


    Для примера рассмотри функцию сложения 2 чисел

    ===================
    ЭТАП ВТОРОЙ
    Создаем новую функцию очистки экрана. Создаем выше чем наша функция int main ()
    ===================

    vo >clear () //void обозначает, что функция не возвращает никакого типа
    <
    system ( “cls” ); //Аналог очистки экрана из статьи С++ первая программа Очистка экрана clrscr();
    return; //Когда функция не возвращает никакого типа, то return можно прописывать просто return;
    //пишем в main () вызов этой фунции
    >

    ===================
    ЭТАП ТРЕТИЙ
    Создаем новую функцию сложения двух чисел int summa (). Пишем её выше чем int main () можно перед clear () можно после clear () Главное написать до того как её вызываем. Вызывать будем в main ()
    ===================

    vo >clear () //void обозначает, что функция не возвращает никакого типа
    <
    system ( “cls” ); //Аналог очистки экрана из статьи С++ первая программа Очистка экрана clrscr();
    return; //Когда функция не возвращает никакого типа, то return можно прописывать просто return;
    //пишем в main () вызов этой фунции
    >

    int summa (int a ,int b ) //В скобках указываем параметры для обработки, так как мы выполняем сложение, то перед названием функции указываем возвращаемый тип
    <
    return a + b ; //Переданные числа будут присвоены в a и b, после чего функция вернет результат их суммы
    // пишем вызов в main ()
    >

    int main ()
    <
    clear (); //Вызываем созданную функцию
    cout summa ( 6 , 4 ); // Вызываем функцию summa(int a,int b) передаем ей 2 параметра. В качестве параметров выступают 2 числа. Эти числа передаются в a и b в функцию . Выводим возвращемое значение на экран. Возвращаемое значение = return a+b; (см в теле функции)
    getch ();

    return 0 ;
    >
    ==========================

    Таким образом мы создали 2 подпрограммы. Первая подпрограмма – это функция, которая очищает экран и не возвращает никакого значения, вторая подпрограмма – это функция, которая получает различные параметры и обрабатывает их согласно нашим условиям. Для закрепления материала приведу пример выполняющий сложение 1+1, 1+2, 1+3..1+N

    int summ ()
    <
    int x = 0 ; //Нужно запоминать результат сложения, будем запоминать в x
    for (int i = 0 ; i N ; i ++) x = x + i + 1 ;
    //Суммирование с помощью цикла и запоминание результата в x
    return x ;
    //Возвращение результата x
    >

    int main ()
    <
    system ( “cls” ); //Очистка экрана
    cout “N = “ ; cin >> N ;
    cout summ ();

    getch (); //Ожидание нажатия клавиши

    return 0 ;
    >

    Цикл While С++ для Начинающих

    Конструкция цикла очень простая.
    while ( наша переменная конечное значение )
    <
    Наш код
    >

    Выполняется повторение нашего кода внутри скобок. Знак ,!=,==). Читается цикл как “До тех пор пока выполняется наше условие, мы будем выполнять этот код”

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

    int main ()
    <
    system ( “cls” ); //Аналог очистки экрана из статьи С++ первая программа Очистка экрана clrscr();
    int a ; //Наша переменная
    //Запускаем генератор случайных значений
    srand ( time ( 0 ));

    while ( a != 50 ) //Наш цикл будет выполнятся до тех пор – пока a не примет значение 50
    <
    a = rand ()% 100 ; //a принимает случайное значение от 0 до 100
    cout a ” “ ; //выводим a на экран через пробелы
    >

    getch ();
    return 0 ;

    При каждом запуске программы будет выведено разное количество чисел. Конструкция цикла While в C++ достаточно проста и для начинающих не должно возникнуть вопросов в её использовании. Но стоит помнить, что равенство в C++ обозначается как ==

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

    ====================================
    Кроме описанного выше, существуют и другие способы использования цикла while.

    int i = 0 ;
    do
    cout i “\n” ;
    while ( i ++ 10 );

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

    while ( i ++ 10 )
    <
    cout i “\n” ;

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

    ========================
    Вы часто будете встречаться с разной записью увеличения (уменьшения) счетчика. У начинающих возникают вопросы чем отличается i ++ от ++ i . ( i — от — i )

    Прата А.С. – Для встроенных типов данных разницы нет, но для типов определенных пользователем, оснащенных операциями инкремента и декремента префиксная форма более эффективна.

    Инкремент i ++ (++ i ) //i=i+1;
    Декремент i — (– i ) / / i= i-1
    Префиксная форма ++ i (– i )
    Постфиксная форма i ++ ( i –)

    Проверка деления числа нацело на любое другое C++ для начинающих

    Приведу пример проверка числа на делимость в C++. Для наглядности я буду применять цикл for из статьи Цикл for в С++ для начинающих

    Проверка числа на четность делается командой if (!( a % 2 )) где a – это проверяемое число. Например
    if ( ! ( 6 % 2 )) cout “chetno” ; – Выведет на экран chetno .
    if ( ! ( 7 % 2 )) cout “chetno” ; – Не выведет ничего

    В коде С++ это выглядит так
    ======================================

    int main ()
    <
    int i , a ;
    for ( i = 1 ; i 100 ; i ++)
    <
    a = i ; //Присваиваем в a значение i. Т.е. сначала проверяется 1/2, потом 2/2, потом 3/2 и так далее пока не проверится 100/2
    if ( ! ( a % 2 )) cout a ” “ ; //Выводим все числа, которые делятся на 2 и разделяем их пробелом
    >
    getch (); // Ожидаем нажатие клавиши

    return 0 ;
    >
    ======================================
    Для проверки четности доступны и другие способы., но я о них писать не буду. Этот способ проверки деления числа на число мне нравится потому что позволяет проверять не только четность. Пусть это не самый быстрый способ. Главное он работает.

    Напишем программу, в которой мы сами задаем условие от начального числа до числа N вывести все числа, которые делятся на К

    Здесь надо понимать, что мы будем работать с переменными, которых будет несколько.
    1) Начальное число. Назовем переменную nach
    2) Конечное число . Назовем переменную n
    3) Само число – Назовем a
    4) Число на которое делим. Назовем b
    5) Счетчик i

    Надеюсь почему переменных 4+1 должно быть понятно. Начало -Конец. Делимое и Делитель. + счетчик, так как для выполнения задачи нужно использовать цикл
    После того как определились, пишем программу С++
    ======================================

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

    Стоит использовать прошлый материал и поработать, например с одномерным массивом и генератором случайных значений. Статьи Одномерный массив в C++ для начинающих и Генератор случайных значений С++ для начинающих Это будет полезно для усвоения материала и укрепления знаний С++

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

    Пишем код
    ======================================
    #include
    #include
    #include
    //для генератора случайных значений
    #include

    int main ()
    <
    int M [ 99 ];
    //Объявили массив, в котором 99 значений (отсчет от нуля)
    srand ( time ( 0 ));
    //Запускаем генератор случайных чисел
    for (int i = 0 ; i 99 ; i ++)
    <
    M [ i ]= rand ()% 101 ;
    //Случайные числа [0..100]
    cout M [ i ] ” “ ;
    //Выводим на экран те числа, которые получились и разделяем их пробелом
    >
    //Массив заполнили. Теперь в нем находится конкретная последовательность значений, которую мы можем обрабатывать так как нам нужно

    cout endl endl “Delitsa na 7” endl ; //После вывода массива на экран вставляем 2 пустые строчки и Пишем: “Делится на 7”, после чего проверяем числа внутри массива, и если они делятся на 7 – выводим их на экран


    for ( i = 0 ; i 99 ; i ++) //Для прохода по массиву используем цикл. Обращаемся к каждому его значению отдельно.
    <
    if (!( M [ i ]% 7 )) cout M [ i ] ” “ ;
    //Главная проверка. Если элемент из массива нацело делится на 7, то мы выводим его на экран
    >

    getch (); //Ожидание нажатия Enter
    return 0 ;
    >

    ======================================

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

    Также для более хорошего усвоения поясню: Проверка происходит по наличию остатка. Арифметическая операция % возвращает остаток от деления. ! обозначает логическое отрицание. Запись if (!( M [ i ]% 7 )) читается как – если остаток от деления ноль, то …

    Аналогична такая запись if ( M [ i ]% 7 == 0 ) / /Здесь нет логического отрицания, но это то же самое

    Деление чисел C++ для начинающих. Округление числа

    Округлить число в C++ можно так

    #include //Эта директива позволяет получать округленное число

    int main ()
    <
    clrscr ();
    double x = floor ( 7 / 3 )/ 100 ; //Присваиваем в x число равное 7/3 и округляем его до сотых
    cout x ; //Выводим на экран полученное значение.
    getch (); //Ожидаем нажатие любой клавиши
    return 0 ; //Заканчиваем программу и выходим из функции
    >

    Вот так легко округляется число до определенного числа знаков после запятой
    Маленькое, но очень полезное в С++ для начинающих дополнение.

    Для округления числа достаточно подключить директиву math.h ииспользовать функцию floor В скобках мы указываем наше вычисление, которое хотим округлить, а после скобок через дробь то значение, на которое округляем.

    Та же самая запись, что и выше, но для наглядности Начинающим в C++ может очень пригодится
    int main ()
    <
    clrscr ();
    int a = 7 , b = 3 ;
    double x = floor ( a / b )/ 100 ; //Присваиваем в x число равное 7/3 и округляем его до сотых
    cout x ; //Выводим на экран полученное значение.
    getch (); //Ожидаем нажатие любой клавиши

    ================
    Было рассмотрено стандартное округление, которое знакомо нам со школы. Но есть и другие типы округлений

    1) Округление до наименьшего целого, не меньше чем округляемое число
    ceil ( x ) x- это наше число
    ceil ( 5.01 ) ; Результат округления 6
    ceil ( 5.9 ); Результат округления 6

    2) Округление до наибольшего целого, не больше чем округляемое число
    floor ( x ) – x это наше число
    функция floor ( x ) отбрасывает дробную часть. Дробную часть можно сохранить до нужных долей. Этот пример округления был рассмотрен выше

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

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

    #include
    int main()
    <
    clrscr(); //Очищаем экран
    char s1; //Объявляем переменную s1
    s1[0]=*”y” //Присвоение переменной s1 значения
    cout = нужно было поставить знак * и нужнобыло объявить номер элемента (ноль соответствет первому)

    Но переменную char чаще используют как массив каких-то символьных значений. Знакомство с простым массивом было изложено в статье
    Одномерный массив в C++ для начинающих

    Для работы с массивами часто необходимо использовать циклы. В прошлой статье был использован цикл for. Про ккотрый описано в статье
    Цикл for в С++ для начинающих

    Т.е. часто символьную переменную объявляют как набор одинарных символов. Даже строковая переменная, о которой я когда-нибудь тоже напишу – это не более чем набор значений типа char

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

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

    Второй вопрос передо мной встал как – а как обнулить переменную типа char в C++ ?, при поиске я почему-то натыкался на исходник целой функции, которая была написана не самым понятным для новичков языком. На этот вопрос я легко смог ответить, когда понял как такой переменной присваивать значения.
    т.е. Если у нас переменная s1 равна Буква y, но нам нужно её очистить, то мы это делаем так
    s1=*””

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

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

    int main()
    <
    char s1 [100]; //Объявляем переменную s1
    return 0;
    >
    Почти равносилен тому, что мы объявили строку, состоящую из 101 символа.
    Если не понимаете почему 101, а не 100 – лучше изучайте массивы. Напоминаю пример простого массива приведен в одной из прошлых статей Одномерный массив в C++ для начинающих

    Есть небольшой нюанс при обработке массива. Так как для обработки мы используем цикл, то если объявленный нами символьный Массив типа char в 101 символ, содержит, например, 5 символов, то неразумно использовать цикл пока мы не достигнем конца нашего массива. – Потомучто если в программе будут тысячи таких операций – это существенно замедлит скорость работы программы

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

    Для того, чтобы обнулить наш символьный массив s1 типа Char на языке программирования C++, после его объявления мы пишем такой код

    Работа с текстовым файлом в C++ для начинающих

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

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

    Пишем код Как считать строки из файла на C++ ?

    int main ()
    <
    char s1 [ 255 ] // Переменная будет считывать строку
    ifstream in ( “C:\\\FromC\\myfile.txt” ); // Открываем файл для считывания информации
    in >> s1 ; // считываем строку
    in . close () // Закрываем файл

    cout s1 ; // Выводим значение s1 на экран
    return 0 ;
    >

    Вот наипростейшая программа для считывания первой строки из текстового файла, который находится по пути
    C:\\\FromC\\myfile.txt –
    Так как это продолжение прошлой статьи , то я решил использовать тот файл, который мы там создавали. Трудностей с этим, наверное возникнуть не должно.
    Но вернемся к коду. Сначала мы открываем файл для считывания из него информации, для этого используем команду ifstream , в скобках указываем либо название файла, либо путь к файлу, как сделано у меня.( “C:\\\FromC\\myfile.txt” );
    Когда мы открыли файл, чтобы считать из него что-то, мы объявили одну переменную типа char –
    char s1 [ 255 ]
    Теперь нам осталось только присвоить переменной значение строки из файла. Это мы делаем командой in
    Обращаем внимание на угловые скобки in >>
    Собственно, как должно быть видно из комментариев к коду программы, то чтобы переменная присвоила считываемое значение, мы должны написать её после in >>
    in >> s1 ;

    Никакой особо сложной задачей это не представляется, особенно если вы уже прекрасно освоили и научились использовать материал прошлой статьи – всё абсолютно аналогично, только 2 команды другие

    Создание файла и запись в него информации С++


    Чтение текста из файла и вывода текста на экран в C++

    ifstream in ( Имя файла );
    in >> ( Считываем строку );
    in. close (); ( Закрываем файл )
    ============================
    Напишем простую программу, которая будет считывать ввод с клавиатуры текста и записывать его в файл:

    int main ()
    <
    char a [ 255 ], b [ 255 ], c [ 255 ]; \\ 3 будущие строки
    clrscsr (); // Очищаем экран

    cout “Wwedi pervuu stroku” ; cin >> a ; endl ;
    cout “Wwedi wtoruu stroku” ; cin >> b ; endl ;
    cout “Wwedi tretuu stroku” ; cin >> c ; endl ;
    clrscr (); // После ввода значений очистили экран

    /*Начинаем работу с файлом*/
    ofstream out ( “C:\\\FromC\\myfile.txt” ); // Открываем файл для записи
    out a “\n” ; // Записываем первую строчку
    out b “\n” ; // Записываем вторую строчку
    out c “\n” ; // Записываем третью строчку
    out . close (); // Закрываем файл

    for (int i = 0 ; i 255 ; i ++)

    ifstream in ( “C:\\\FromC\\myfile.txt” );
    in >> a >> b >> c ; // Считываем каждую новую строчку в новую переменную
    in . close (); // Закрываем файл

    for ( i = 0 ; a [ i ]!=* “” ; i ++)
    <
    if ( i >sizeof( a )) break ;
    cout a [ i ];
    >
    cout “\n” ; \\ Перевели курсор на новую строчку

    for ( i = 0 ; b [ i ]!=* “” ; i ++)
    <
    if ( i >sizeof( b )) break ;
    cout b [ i ];
    >
    cout “\n” ; \\ Перевели курсор на новую строчку

    В приведенных выше примерах есть один такой ОГРОМНЫЙ недостаток. Если мы будем пытаться ввести строчку, содержащую пробелы, то программа будет срабатывать не так как нам нужно. Наверное, на эту ошибку наткнулся не только я, но и многие другие люди. Поэтому я оставляю неверно приведенный код, чтобы было видно с чем можно столкнуться.

    Так как книжек дома нет, я снова стал рыскать в интернете и понаходил много всякой мудреной ерунды. Но всё-таки как-то подобрал решение своей проблемы.
    Помогло то, что читал о том, что cout поддерживает свои методы. И в интернете все советы идут на использование функции getline К моему счастью как использовать эту функцию я нашел очень быстро и потом использовал ее в коде.
    Вообще стоит упомянуть и описать эту функцию, но пока что я не особо её понимаю, просто понимаю, что её нужно использовать и понимаю как, поэтому привожу более правильный пример нашей разрабатываемой программы:

    int main ()
    <
    char a [ 255 ], b [ 255 ], c [ 255 ]; \\ 3 будущие строки
    clrscsr (); // Очищаем экран

    cout “Wwedi pervuu stroku” ; cin.getline(a,sizeof(a)); endl ;
    cout “Wwedi wtoruu stroku” ; cin.getline(a,sizeof(b)); endl ;
    cout “Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); endl ;
    clrscr (); // После ввода значений очистили экран

    /*Начинаем работу с файлом*/
    ofstream out (“C:\\\FromC\\myfile.txt”); // Открываем файл для записи
    out a “\n” ; // Записываем первую строчку
    out b “\n” ; // Записываем вторую строчку
    out c “\n” ; // Записываем третью строчку
    out . close (); // Закрываем файл

    for (int i = 0 ; i 255 ; i ++)

    if stream in ( “C:\\\FromC\\myfile.txt” );
    in.getline(a,sizeof(a)); // Считываем строчку в переменную а
    in.getline(b,sizeof(b)); // Считываем строчку в переменную b
    in.getline(c,sizeof(c)); // Считываем строчку в переменную c
    in . close (); // Закрываем файл

    for ( i = 0 ; a [ i ]!=* “” ;i++)
    <
    if ( i >sizeof( a )) break ;
    cout a [ i ];
    >
    cout “\n” ; \\ Перевели курсор на новую строчку

    for ( i = 0 ; b [ i ]!=* “” ; i ++)
    <
    if ( i >sizeof( b )) break ;
    cout b [ i ];
    >
    cout “\n” ; \\ Перевели курсор на новую строчку

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

    В остальном, приведенный пример, как в C++ считать строки из текстового файла должен быть доступен и вполне понятен. Это сейчас не оптимальный вариант реализации, и я упустил некоторые важные моменты, но так как у нас начало изучения языка C++, то этого пока вполне достаточно. Попозже я наверняка дойду до упущенного, а сейчас нужно воспринимать только самое необходимое.

    Если мы вместе с вами поняли этот материал, то значит продвинулись на маленький шажок к своему профессионализму.

    Примечание:
    break ; – Это команда, которая выполняет выход из цикла. У нас если счетчик цикла for становится больше чем объявленный размер переменной char, то мы принудительно выходим из цикла
    != – это поставленное нами условие. Обозначает такое условие неравенство
    if( a != b ) – Читается как если a не равно b
    Начальное ознакомление с циклом for тут

    endl ; – Это перевод курсора на новую строку внутри консоли (насколько я понял)
    Эта команда похожа на “\n”

    Дальше в материале использованы функции. Если вы знаете, что это и как их используют, то материал по теме:
    C++ Для начинающих вывести текст из файла на экран
    Без понимания работы функции будет тяжело понять

    Работа с текстовым файлом в C++ для начинающих

    Так как на момент написания этой статьи я отношусь к категории С++ для начинающих, мне стало интересно как записать текстовый файл на С++ . Забавно, что при поиске в интернете я далеко не с первого раза нашел нужную мне информацию и кое что из того что пишу не нашел вообще. Это не обозначает, что я плохо искал или то, что я искал нет в интернете, просто если это есть, то лежит где-то глубоко в форумах, глубоко в поиске.
    Работа с текстовым файлом в C++ совсем не сложная и предлагались разные варианты как записать текст в текстовый файл на языке C++ Но, как я говорил вначале – для начинающего изучение C++ очень нужна простота (чем проще понять базовые возможности – тем проще их будет использовать). Позже появятся какие-то навыки, они помогут совершенствовать быстродействие своих проектов, или созданию минимальных по размеру исполняемых файлов.
    Чем удобнее и проще написан наш код – тем проще нам его использовать и выявлять ошибки на стадии изучения C++.

    Вариантов реализации каких-то необходимых функций много, предлагаемый мной – это только один из тех, которые существуют

    Итак, чтобы обработать текстовый файл – мы должны подключить диррективу fstream.h

    Взятый и приводимый мною пример очень похож на вывод текста на экран средствами С++
    только там мы использовали cout – а тут для записи текста в файл будем использовать out
    (Просто убираем первую букву и получаем аналогию команды)

    Пишем код, создающий текстовый файл:

    int main ()
    <
    ofstream out ( “myfile.txt” );
    out.close ();
    return 0 ;
    >
    =============================
    Вот такая программа создаст нам файл myfile.txt в директории где установлен C++ (по умолчанию в папке BIN). Если файл существовал, то всё что на нём было записано сотрется – Так, что будьте аккуратнее.

    ofstream out – Это поток вывода. В скобках после этой команды указывается путь к файлу – Если мы указываем только имя файла, то наша программа будет пытаться открыть файл по адресу где расположен исполняемый файл. Если нам удобно использовать какой-то отдельный каталог, то можно написать например так:

    ofstream out ( “E:\\\NewKatalog\\myfile.txt” )
    В этом случае файл будет открыт и записан по адресу Диск E в Папке NewKatalog под именем myfile.txt
    out.close (); – Так мы закрываем открытый нами для обработки файл. Закрывать открытый файл ОБЯЗАТЕЛЬНО

    Примечание – Чтобы проверить пример – Для успешного создания файла в папке NewKatalog –Каталог NewKatalog на диске E:\ уже должен существовать

    Пример записи файла MyFile.txt по пути C:\Windows\Temp (Проверено в XP SP2)

    Если у вас стоит, например, WinXP на диске C:\ и в переменных средах указана временная папка Temp с путем C:\WINDOWS\Temp\ – то такой пример должен сработать. В папке Temp должен появится пустой файл с именем myfile.txt

    Проверить переменную среду в XP можно вызвав контекстное меню Моего компьютера –
    Свойства – Дополнительно – Переменные среды. В нижнем окне прописаны пути.
    =============================

    C записью файла надеюсь мы разобрались и даже знаем теперь, как записать файл в отдельную директорию средствами C++


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

    Давайте разбираться как записывать в файл информацию. У меня статья про текстовый файл – поэтому попробуем записать в файл myfile.txt 2 строчки:

    HelloWorld
    Ura. Rabotaet

    Для удобства и привыкания создадим отдельную папку на диске C:\ – Назовем её FromC – туда и будем записывать создаваемый файл, в который, соответственно, запишем нужные строки, используя С++ .

    int main ()
    <
    ofstream out ( “C:\\\FromC\\myfile.txt” ); // Открываем файл для записи
    out “HelloWorld” “\n” ; // Записываем первую строчку
    out “UraRabotaet. ” // Записываем вторую строчку
    out.close (); // Закрываем файл
    return 0 ;
    >

    Не забывайте – что такая программа папок не создает, а создает только файл, и если папка не существует – файл не создастся.
    Компилируем программу (Ctrl+F9 или Run-Run) – Смотрим в папку FromC – Если всё правильно сделали – то должен был появиться файл myfile.txt и в файле должно было появиться 2 строчки, которые хотели записать, используя С++.

    ======================================
    Здесь есть небольшой недостаток, я его оставляю, потомучто одна моя очень значительная и наверняка очень распространенная ошибка описана дальше, в следующей статье
    ЧИТАТЬ ПРОДОЛЖЕНИЕ

    C++ — помогите в C++; при любом вводе выводит что y = 0

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

    Задача 2

    Написать программу, которая выводит таблицу перевода расстояний в дюймах в сантиметры для значений от n до m дюймов (1 дюйм = 2,54 см)

    Задача 3

    Начав тренировки, спортсмен в первый день пробежал М км. Каждый день он увеличивал дневную норму на Р% нормы предыдущего дня. В какой день впервые спортсмен пробежит более K км?

    Задача 4

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

    Задача 5

    Написать программу, которая выводит таблицу умножения числа N в интервале от L до K. Ввод N, L,K выполнять с клавиатуры.

    Задача 6

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

    Задача 7

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

    Задача 8

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

    Задача 9

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

    Задача 10

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

    Задача 11

    Бизнесмен взял ссуду m тысяч рублей в банке под k% годовых. Рассчитать его долг через N лет , если за это время он не будет отдавать долг?

    Задача 12

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

    Русские символы(буквы) при вводе/выводе в консоль на C++

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

    Возникла проблема с отображением русских букв

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

    На языке C++ программирую под ОС Linux, использую компилятор GCC. С проблемой неправильного отображения русских букв я не сталкивался. В момент написания статьи я нахожусь далеко от своего компьютера, могу довольствоваться лишь скромненьким ноутбуком с установленной ОС Windows Seven. Захотелось покодить и я установил на него интегрированную среду разработки Dev-C++ 5.10(использует компилятор TDM-GCC 4.8.1 на базе GCC 4.8.1). Кстати, она уже официально не поддерживается, но существует форк Orwell Dev-C++, который обновляется по сей день. Установив, я запустил и для пробы написал простую программку, которая отображает текст «Привет, мир!». Но поздороваться она с миром так и не смогла, а лишь сказала что-то непонятное на древнеегипетском. После перелопачивания некоторых форумов и сайтов я нашел множество советов, но основная масса не способна была решить её полностью, образовывались подводные камни о которых расскажу далее.

    После написания, компиляции и запуска такой программы:

    C++ — помогите в C++; при любом вводе выводит что y = 0


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

    Простым числом называется отличное от 1 натуральное число, делящееся только на себя и на 1.

    . Задача . Написать программу нахождения первых n простых чисел в натуральном ряду.

    . Составляем программу . Шапка программы как у « calc »: состоит из трёх директив и одной строки.

    . Строка объявления переменных содержит массив num, с простым числом 2 в нулевой ячейке:

    Название массива образовано от слова «number» — «число». В его ячейках будем хранить простые числа.

    . Функция simpl(n) зависит от числа n простых чисел. Начинается она с вывода на экран заголовка будущей таблицы:

    . Далее будут использованы внешний и внутренний операторы цикла for и один условный оператор if.

    . Во внутреннем операторе цикла for при помощи функции fmod из математической библиотеки находим остатки r от деления числа, находящегося в ячейке массива с номером i, на все числа из предыдущих ячеек (с номерами от k = до k = i1):

    . При помощи условного оператора if анализируем остатки от деления. Если хотя бы один окажется равным нулю (обнаружен делитель!), то управление передается внутрь фигурных скобок оператора if (отмечены красным цветом), число в ячейке увеличивается на 1, счётчик цикла обнуляется, и процесс повторяется.

    . Из внутреннего цикла программа выйдет в том случае, когда в ячейке с номером i окажется простое число, которое при помощи оператора cout появится на экране. Обозначение » \t » используют для сдвига столбцов таблицы на несколько пробелов вправо. Не забываем, что нумерация ячеек массива начинается с , поэтому в i-той ячейке будет находиться простое число под номером i+1

    . Внешний оператор цикла

    заносит в очередную ячейку число, большее на единицу простого числа в предыдущей ячейке, и передаёт управление внутреннему оператору цикла (он находится на месте многоточия), который заносит в эту ячейку очередное простое число. Перебираем все ячейки массива с номерами от i = до i = n1.

    . Открываем компилятор Visual Studio и создаём проект « simple » — « простое число ». В открывшемся файле simple.cpp всё стираем и вставляем туда приведенную ниже программу.

    Стандартная схема программы « simple »

    #include «stdafx.h»
    #include
    using namespace std;
    #include

    cout «Первые » » простых чисел» for ( int i=0; i for ( int k=0; k double r=fmod(num[i], num[k]);
    if (r==0)
    >
    cout «\t» «. \t» void main( )
    <
    setlocale(LC_ALL, «Rus» );
    simpl(10);
    cin.get();
    >

    . Главная функция программы main() начинается оператором русификации текста и заканчивается фиксацией экрана. В середине при помощи функции simpl(10) вычисляем первые 10 простых чисел натурального ряда.

    . Cобираем операторы в единую программу и помещаем её в файл simple.cpp . Программа расположена слева и служит для нахождения первых n простых чисел натурального ряда.

    . Нажимаем F5 и получаем результат:

    . Чтобы найти другое количество простых чисел натурального ряда, в главную функцию программы main в качестве аргумента функции simpl(10) подставляем вместо 10 другое число.

    C++ и гарем Абдуллы.
    Символьные переменные

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

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

    . Например, присвоим переменной x букву ю (одинарные кавычки обязательны!):

    . Внимание! Этим оператором мы говорим компьютеру: запомни, паршивец, число 254!

    . Чтобы доходчиво объяснить этот парадокс, предположим (я не исключаю такого варианта!), что в число дремучих чайников попали люди творческих профессий. Тогда 254 — это псевдоним буквы ю , который передается компьютеру.

    . Я не исключаю также возможности, что в число дремучих чайников попадут люди, отбывавшие срок в заключении. Тогда, если доходчиво, 254 — это «кликуха» буквы ю для компьютера.

    . Существует специальная таблица ASCII Win-1251 (не буду расшифровывать), где каждому символу ставится в соответствие код — определенное трехзначное число от до 255.

    . Вот, например, как можно записать и зашифровать любимую жену Абдуллы из кинофильма «Белое солнце пустыни». При выводе на экран все три выражения содержат одно и то же слово: «Гюльчатай».

    . Одинарные кавычки ‘ ‘ говорят о том, что внутри массива находится символ. Буквы слова, заключенного в двойные кавычки » » , распределяются по ячейкам символьного массива gar3[ ]. Квадратные скобки можно оставить пустыми — компьютер самостоятельно вычислит длину массива.

    . Псевдонимы (коды) символов — это не обычные, а о чар ованные числа. Их нельзя перемножать, делить. Однако создатели языка С++ решили дать им немного свободы и разрешили кое-что к ним прибавлять. Например, выводим на экран char x = <65>, получаем букву A. Выводим на экран char y = x + 1, получаем B, поскольку псевдоним этой буквы 66.

    . Чтобы понять суть символьных переменных, составим небольшую программу « garem » — « гарем » на примере жён Абдуллы. Шапка состоит из трех операторов (как у программы « text »). Вот верхняя часть программы « garem »:

    . Строка объявления переменных превратилась в таблицу. Заявлено четыре массива статуса char и одна переменная int . В ячейки массива nal1 (от слова «наложница») занесем по буквам имя первой жены Абдуллы, а в ячейки nal2 — псевдонимы букв любимой жены. Ячейкам массива gar (от слова «гарем») присвоим имена старших, а ячейкам gar1 — младших жен Абдуллы. Параметр L — это длина массива.

    . Программу « garem » составим по простейшей схеме . Тогда ее нижняя часть будет содержать только функцию main:

    . В теле программы содержится несколько новых операторов. Структура его такова. Сначала выводим на экран содержимое массивов nal1 и nal2. Затем при помощи оператора strcat ( gar, gar1 ) массивы gar1 и gar объединяем в один массив gar и на экран выводим его содержимое — весь гарем Абдуллы.

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

    . При помощи оператора strlen ( gar ) вычисляем длину L (количество ячеек) массива gar.

    Цукерберг рекомендует:  A1000 - Ошибка Assembler
    Понравилась статья? Поделиться с друзьями:
    Все языки программирования для начинающих