К какому типу относится ошибка привет вася

Лекция.
Символьные
строки

План
лекции.

1. Символьные
   массивы.

2. Массив
   или указатель.

3. Различие
   между массивом и указателем.

4. Понятие
   символьной строки.

5. Объявление
   и инициализация строк.

6. Стандартный
   ввод вывод строк.

7. Функции
   для работы со строками.

8. Строки
   в функциях и процедурах.

9. Массивы
   строк.

10. Стандартная
    библиотека обработки строк.

1. Cимвольные
   массивы.

При
определении массива символьных литернеобходимо сообщитькомпиляторутребуемый размер памяти.

char
m[82];

Компилятор
также может самостоятельно определить
размер массива символов.

char
m2[]=»Горные вершины спят во тьме
ночной.»;

char
m3[]={‘Т’,’и’,’х’,’и’,’е’,’ ‘,’д’,’о’,’л’,’и’,’н’,’ы’,’
‘,’п’,’о’,’л’,’н’,’ы’,’ ‘,’с’,’в’,’е’,’ж’,’е’,’й’,’
‘,’м’,’г’,’л’,’о’,’й’,»};

Как
и для других массивов, m2 и m3 являются
указателями на первые элементы массивов.

m2
== &m2[0]

*m2
== ‘Г’

*(m2
+ 1) == ‘o’

m3
== &m3[0]

*(m3
+ 2) == ‘x’

Для
создания строки можно использовать
указатель.

char
*m4 = «Не пылит дорога, не дрожат
листы…»;

Это
почти то же самое, что и

char
m5[] = «Подожди немного, отдохнешь и
ты»; .

В
обоих случаях m4 и m5 являются указателями
на строки, и размеры массивов определяются
компилятором. Однако между m4 и m5 есть и
некоторая разница.

Во
втором случае объявление массива
вызывает создание в памяти массива из
32 элементов (по одному на каждый символ
плюс один на завершающий символ »).
Каждый элемент инициализируется
соответствующим символом. В дальнейшем
компилятор будет рассматривать имя m5
как синоним адреса первого элемента
массива, то есть &m5[0]. Следует отметить,
что m5 является константой—указателем.
Нельзя изменить m5, так как это
означало бы изменение положения (адреса)
массива в памяти. Можно использовать
операции, подобные m5 + 1, для идентификации
следующего

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

В
случае с указателем m4 в памяти создается
36 элементов для запоминания

строки.
Но, кроме того, выделяется еще одна
ячейка памяти для переменной m4,

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

увеличения;
++m4 будет указывать на второй символ
строки — ‘е’.

3. Различия между массивами и указателями.

Рассмотрим
различия в использовании описаний
следующих двух видов:

char
heart [] = «Подожди немного, «; .

char
*reason = «отдохнешь и ты.»; .

Основное
отличие состоит в том, что указатель
heart является константой, в

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

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

for
(i = 0; i < 17; i+ + )

putchar(*
(heart + i) );

putchar(‘n’)

for
(i = 0; i < 15; i+ + )

putchar(*
(reason + i) );

putchar(‘n’);

Результат
работы

Подожди
немного, отдохнешь и ты.

В
случае с указателем можно использовать
операцию увеличения.

/*
останов в конце строки */

while
( *( reason) != »

/*
печать символа и перемещение указателя
*/

putchar(
*( reason + + ) );

Результат
работы

отдохнешь
и ты.

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

char
ml[36] = «В полдневный жар в долине
Дагестана»;

вместо

char
ml[ ] = » В полдневный жар в долине
Дагестана»; .

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

1. Понятие
   символьной строки.

Понятно,
что
символьная
строка
–
это
последовательность
символов.
Мы
будем
рассматривать
строки,
в
которых
на
каждый
символ
отводится
1 байт.
В
этом
случае
можно
использовать
28=256 различных
символов.
Каждый
символ
имеет
свой
код
(от
0 до
255), эти
коды
определяются
по
специальной
таблице.

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

1)
хранить
длину
строки
в
отдельной
ячейке
(как
в
языке
Паскаль);

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

В
языке
Си
принят
второй
подход.

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

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

Символ
с
кодом
ноль
(обозначается
как
»)
и
цифра
ноль
(обозначается
‘0’,
имеет
код
48) – это
два
разных
символа.

1. Объявление
   и
   инициализация.

Строка
представляет
собой
массив
символов,
поэтому
и
объявляется
она
имен-но
как
массив:

char
s[80];

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

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

char
s[80] = «Привет,
Вася!»;

Символы
в
кавычках
будут
записаны
в
начало
массива
s,
а
затем
–
признак
око-нчания
строки
».
Оставшиеся
символы
не
меняются,
и
в
локальных
строках
там
будет
«мусор».
Можно
написать
и
так

char
s[] = «Привет,
Вася!»;

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

char
*s = «Привет,
Вася!»;

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

const
char PRIVET[] = «Привет,
Вася!»;

6.
Стандартный
ввод
и
вывод.

Для
ввода
и
вывода
строк
с
помощью
функций
scanf
и
printf
спользуется
специальный
формат
«%s»:

#include
<stdio.h>

main()

{

char
Name[50];

printf(«Как
тебя
зовут?
«);

scanf(«%s»,
Name);

printf(«Привет,
%s!», Name);

}

Заметим,
что
в
функцию
scanf
надо
передать
просто
имя
строки
(без
знака
&),
ведь
имя
массива
является
одновременно
адресом
его
начального
элемента.

Однако
у
функции
scanf
есть
одна
особенность:
она
заканчивает
ввод,
встретив
первый
пробел.
Если
вы
на
вопрос
в
предыдущем
примере
ввели
«Вася
Пупкин«,
то
увидите
надпись
«Привет,
Вася!»
вместо
ожидаемого
«Привет,
Вася
Пупкин!».
Если
надо
ввести
всю
строку
целиком,
включая
пробелы
(то
есть
до
нажатия
на
клавишу
Enter),
придется
делать
иначе,
заменив
вызов
scanf
на
более
простой:
gets
( s );

Название
этой
функции
происходит
от
английских
слов
get
string – получить
строку.

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

#include
<stdio.h>

main()

{

char
Name[50] = «Вася!»;

puts(
«Привет,»
);

puts
( Name );

}

Задача.
Ввести
символьную
строку
и
заменить
в
ней
все
буквы
‘A’
на
буквы
‘Б‘.

Будем
рассматривать
строку
как
массив
символов.
Надо
перебрать
все
элементы
массива,
пока
мы
не
встретим
символ
»
(признак
окончания
строки)
и,
если
очередной
символ
–
это
буква
‘A’,
заменить
его
на
‘Б‘.
Для
этого
используем
цикл
while,
потому
что
мы
заранее
не
знаем
длину
строки.Условие
цикла
можно
сформулировать
так:«пока
не
конец
строки».

#include
<stdio.h>

main()

{

char
a[80];

int
i;

printf(
«n Введите
строку
n» );

gets
( s );

i
= 0; //
начать
с
первого
символа,
s[0]

while
( s[i] != » ) //
пока
не
достигли
конца
строки

{

if
( s[i] == ‘A’ ) //
если
очередной
символ
–
‘A’, …

s[i]
= ‘Б‘;
//
меняем
его
на
‘Б‘

i
++; //
переходим
к
следующему
символу

}

puts
( «Результат:n»
);

puts
( a );

}

Заметьтим,
что
одиночный
символ
записывается
в
апострофах,
а
символьная
строка
–
в
кавычках.
При
выводе
строк
с
помощью
функции
printf
часто
применяется
форматирование.
После
знака
%
в
формате
указывается
размер
поля
для
вывода
строки.
Перед
этим
числом
можно

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

Пример
вывода
Результат
Комментарий

printf(
«[%s]», «Вася«);
[Вася]
Минимальное
число
позиций.

printf(
«[%6s]», «Вася«);
[ Вася]
6
позиций,
выравнивание
вправо.

printf(«[%-6s]»,
«Вася«);
[Вася
] 6
позиций,
выравнивание
влево.

printf(
«[%2s]», «Вася«);
[Вася]
Строка
не
помещается
в
заданные
2

позиции,
поэтому
область
вывода
расширяется.

7.
Функции
для
работы
со
строками

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

#include
<string.h>

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

Длина
строки
–
strlen

Это
самая
простая
функция,
которая
определяет,
сколько
символов
в
переданной
ей
строке
(несчитая
»).
Ее
имя
происходит
от
английских
слов
string
length
(длина
строки).

#include
<stdio.h>

#include
<string.h>

main()

{

int
len;

char
s[] = «Prodigy»;

len
= strlen(s);

printf
( «Длина
строки
%s равна
%d», s, len );

}

В
этом
примере
функция
определит,
что
длина
строки
равна
7.

Сравнение
строк
–
strcmp

Для
сравнения
двух
строк
используют
функцию
strcmp
(от
английских
слов
string
comparison
–
сравнение
строк).
Функция
возвращает
ноль,
если
строки
равны
(то
есть
«разность»
между
ними
равна
нулю)
и
ненулевое
значение,
если
строки
различны.
Сравнение
происходит
по
кодам
символов,
поэтому
функция
различает
строчные
и
заглавные
буквы
–
они
имеют
разные
коды.

#include
<stdio.h>

#include
<string.h>

main()

{

char
s1[] = «Вася«,

s2[]
= «Петя«;

if
( 0 == strcmp(s1,s2) )

printf(«Строки
%s и
%s одинаковы«,
s1, s2);

else
printf(«Строки
%s и
%s разные«,
s1, s2);

}

Если
строки
не
равны,
функция
возвращает
«разность»
между
первой
и
второй
строкой,
то
есть
разность
кодов
первых
различных
символов.
Эти
числа
можно
использовать
для
сортировки
строк
–
если
«разность»
отрицательна,
значит
первая
строка
«меньше»
второй,
то
есть
стоит
за

ней
в
алфавитном
порядке.
В
таблице
показано
несколько
примеров
(код
буквы
‘A’
равен
65,
код
буквы
‘B’
–
66,
код
буквы
‘C’
–
67).

s1
s2 результат
strcmp(s1,
s2)

AA
AA 0

AB
AAB ‘B’ – ‘A’ = 66 – 65 = 1

AB
CAA ‘A’ – ‘C’ = 65 – 67 = -2

AA
AAA » – ‘A’ = -65

Задача.
Ввести
две
строки
и
вывести
их
в
алфавитном
порядке.

#include
<stdio.h>

#include
<string.h>

main()

{

char
s1[80], s2[80];

printf
(«Введите
первую
строку«);

gets(s1);

printf
(«Введите
вторую
строку«);

gets(s2);

if
( strcmp(s1,s2) <= 0 )

printf(«%sn%s»,
s1, s2);

else
printf(«%sn%s», s2, s1);

}

Иногда
надо
сравнить
не
всю
строку,
а
только
первые
несколько
символов.
Для
этого
служитфункция
strncmp
(с
буквой
n
в
середине).
Третий
параметр
этой
функции
–
количество
сравниваемых
символов.
Принцип
работы
такой
же
–
она
возвращает
нуль,
если
заданное
количество
первых
символов
обеих
строк
одинаково.

#include
<stdio.h>

#include
<string.h>

main()

{

char
s1[80], s2[80];

printf
(«Введите
первую
строку«);

gets(s1);

printf
(«Введите
вторую
строку«);

gets(s2);

if
( 0 == strncmp(s1, s2, 2) )

printf(«Первые
два
символа
%s и
%s одинаковы«,
s1, s2);

else

printf(«Первые
два
символа
%s и
%s разные«,
s1, s2);

}

Один
из
примеров
использования
функции
strcmp
–
проверка
пароля.
Составим
программу,
которая
спрашивает
пароль
и,
если
пароль
введен
неверно,
заканчивает
работу,
а
если
верно
–
выполняет
какую-нибудь
задачу.

Задача.
Составить
программу,
которая
определяет,
сколько
цифр
в
символьной
строке.
Программа
должна
работать
только
при
вводе
пароля
«куку».

#include
<stdio.h>

#include
<string.h>

main()

{

char
pass[] = «куку«,
//
правильный
пароль

s[80];
//
вспомогательная
строка

int
i, count = 0;

printf
(«Введите
пароль
«);

gets(s);

if
( strcmp ( pass, s ) != 0 )

{

printf
( «Неверный
пароль»
);

return
1; //
выход
по
ошибке,
код
ошибки
1

}

printf
(«Введите
строку«);

gets(s);

i
= 0;

while
( s[i] != » ) {

if
( s[i] >= ‘0’ && s[i] <= ‘9’ )

count
++;

}

printf(«nНашли
%d цифр«,
count);

}

В
этой
программе
использован
тот
факт,
что
коды
цифр
расположены
в
таблице
символов
последовательно
от
‘0’
до
‘9’.
Поэтому
можно
использовать
двойное
неравенство,
а
не
сравнивать
текущий
символ
s[i]
с
каждой
из
цифр.
Обратите
внимание
на
разницу
между
символами
»
(символ
с
кодом
0, признак
конца
строки)
и
‘0’
(символ
с
кодом
48, цифра
0). Переменная
count
работает
как
счетчик.

Копирование
строк

Часто
надо
записать
новое
значение
в
строку
или
скопировать
информацию
из
одной
строки
в
другую.
Функции
копирования
принадлежат
к
числу
«опасных»
– они
могут
вызвать
серьезную
ошибку,
если
произойдет
выход
за
границы
массива.
Это
бывает
в
том
случае,
если
строка,
в
которую
копируется
информация,
имеет
недостаточный
размер
(под
нее
выделено
мало
место
в
памяти).

В
копировании
участвуют
две
строки,
они
называются
«источник»
(строка,
откуда
копируется
информация)
и
«приемник»
(куда
она
записывается
или
добавляется).При
копировании
строк
надо
проверить,
чтобы
для
строки-приемника
было
выделено
достаточно
места
в
памяти

Простое
копирование
выполняет
функция
strcpy.
Она
принимает
два
аргумента:
сначала
строка-приемник,
потом
–
источник
(порядок
важен!).

char
s1[50], s2[10];

gets(s1);

strcpy
( s2, s1); //
s2 (приемник)
<- s1 (источник)

puts
( s2 );

Этот
фрагмент
программы
является
«опасным»
с
точки
зрения
выхода
за
границы
строки.
В
строку
s1
можно
безопасно
записать
не
более
49 символов
(плюс
завершающий
ноль).
Поэтому
если
с
клавиатуры
будет
введена
строка
длиннее
49 символов,
при
записи
ее
в
память
произой-

дет
выход
за
границы
строки
s1.
Строка
s2
может
принять
не
более
9 символов,
поэтому
при
большем
размере
s1
произойдет
выход
за
границы
строки
s2.
Поскольку
реально
функции
передается
адрес
начала
строки,
можно
заставить
функцию
начать
работу
любого
символа,
а
не
только
с
начала
строки.
Например,
следующая
строка
скопирует
строку
s2
в
область
памяти
строки
s1,которая
начинается
с
ее
6-ого
символа,
оставив
без
изменения
первые
пять:

strcpy
( s1+5, s2 );

При
этом
надо
следить,
чтобы
не
выйти
за
границу
массива.
Кроме
того,
если
до
выполнения
этой
операции
в
строке
s1
меньше
5 символов,
фокус
не
удастся.
Еще
одна
функция
позволяет
скопировать
только
заданное
количество
символов,
она
называется
strncpy
и
принимает
в
третьем
параметре
количество
символов,
которые
надо
скопировать.
Важно
помнить,
что
эта
функция
НЕ
записывает
завершающий
нуль,

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

#include
<stdio.h>

#include
<string.h>

main()

{

char
s1[] = «Ку—ку«,
s2[10];

strncpy
( s2, s1, 2 ); //
скопировать
2 символа
из
s1 в
s2

puts
( s2 ); //
ошибка!
нет
последнего
»

s2[2]
= »; //
добавляем
символ
окончания
строки

puts
(s2); //
вывод

}

Проблемы
при
копировании
строк

При
копировании
стандартные
функции
strcpy
и
strncpy
поступают
так:
определяют
количество
символов,
которые
надо
скопировать
и
затем
переписывают
их,
начиная
с
первого
символа
до
последнего.
Если
области
источника
и
приемника
не
перекрываются,
то
все
прохо-

дит
нормально.
Но
попробуем
«раздвинуть»
строку,
например
для
того,
чтобы
вставить
что-то
в
ее
середину.
Пусть
в
строке
s1
записано
имя
и
фамилия
человека,
а
в
строке
s2
–
его
отчество.

Надо
получить
в
строке
s1
полностью
имя,
фамилию
и
отчество.

#include
<stdio.h>

#include
<string.h>

main()

{

int
n;

char
s1[80] = «Иван
Рождественский«,

s2[]
= «Петрович
«;

n
= strlen(s2); //
длина
второй
строки

strcpy
(s1+5, s1+5+n); //
пытаемся
раздвинуть
на
n символов

strncpy(s1+5,
s2, n); //
вставляем
отчество
в
середину

puts
( s1 );

}

При
первом
вызове
strcpy
мы
хотели
скопировать
конец
строки,
начиная
с
символа
с
номером
5 (он
шестой
с
начала,
так
как
нумерация
идет
с
нуля)
вправо
на
n
символов
(объявленная
длина
массива
символов
–
80 – позволяет
это
сделать).
Однако
из-за
того,
что
копирование
вы-

полнялось
с
начала
блока
данных,
скопировав
на
новое
место
первый
символ
фамилии
(‘Р‘)
функция
стерла
букву
‘н‘
(справа
на
9 символов)
и
т.д.
В
результате
получили
s1
= «Иван
РождествеРождествеРождес«

В
следующей
строчке
мы
скопировали
в
середину
отчество
(без
завершающего
нуля)
и
получили

s1
= «Иван
Петрович
РождествеРождес«

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

Удивлен что ещё проходит обучение по 2 версии питона. Скажи преподу чтобы на 3 переходил

1) Python — Питон

print — Распечатать (Вывод на экран)

2) print «Привет, Вася!»

==1 задачка==

Входные данные мы задаём в коде, либо в ходе выполнения кода:

1)a = 2

b = 3

2)a = int(input(«Ввод:»)

b = int(input(«Ввод:»)

Я бы взял первый вариант.

Сложив 2 и 3,получим 5

«»»Код»»»

a = 2

b = 3

c = a+b

print(c) #Получим 5

Вопросы к заданию:

Типы входных данных:

В двух вариантах он будет один — int (тобишь числовой)

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

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

Результат так же относится к числовому типу int.

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

(не особо понял какие стрелки)

==2 задачка==

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

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

Можно разнообразить наш код, добавив обычный модуль рандомизации, для того чтобы скорость автомобиля не всегда была равна n-числу

В коде будут все комментарии, не запутаешься)

Просто вставь код ниже в свой текстовый редактор.

«»Код»»

import random #Для будущей рандомизации

import time #Для использования задержки времени.

clear = «/n»*500 #Переменная для очистки консоли, с помощью неё наш Навигатор будет красивее

total = 0 #В этой переменной у нас будут храниться данные об пройденном пути

counter = 0 #В этой переменной у нас будет пройденное время.

speed = int(input(«Введите скорость вашего автомобиля:») #В этой переменной мы спрашиваем пользователя об скорости его авто. Понадобиться чтобы сделать в будущем разброс.

while True: #Запускаем бесконечный цикл.

counter = counter + 1

speed_up = random.uniform(speed, speed+5) #Появились вопросы не так ли? Итак, эта функция позволяет нам рандомизировать нашу скорость. Приведу краткий пример random.uniform(1,5), эта функция, выдаст нам рандомное число в диапазоне от 1 до 5

to_total = speed_up / 60 / 60

total = to_total + total

print(clear) #очистка консоли

print(«Скорость автомобиля — » + str(speed_up) + «/nПройденный путь — » + str(total) + » м./nПройденное время — » + str(counter)

«»Конец кода»»

Ответы на вопросы:

Входные данные относятся к числовому типу данных.

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

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

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

===Информация от меня===

Если возникли какие то проблемы по питону, пиши мне в телеграм — @imogokuru

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