Форум программистов, компьютерный форум, киберфорум
Наши страницы
C для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 5.00/6: Рейтинг темы: голосов - 6, средняя оценка - 5.00
Rastafari_
0 / 0 / 0
Регистрация: 21.11.2017
Сообщений: 9
1

Массив: Сформировать и вывести массив размера N, содержащий N первых положительных нечетных чисел: 1, 3, 5

21.11.2017, 10:20. Просмотров 1159. Ответов 14
Метки нет (Все метки)

Дано целое число N ( > 0). Сформировать и вывести целочисленный массив размера N, содержащий N первых положительных нечетных чисел: 1, 3, 5...
0
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
21.11.2017, 10:20
Ответы с готовыми решениями:

Сформировать и вывести целочисленный массив размера N, содержащий N первых положительных нечетных чисел
Дано целое число N (> 0). Сформировать и вывести целочисленный массив размера N, содержащий N...

Сформировать и вывести массив размера N, содержащий N первых членов данной прогрессии по правилу
Дано целое число N(>1), а также первый член A и разность D арифметической прогрессии. Сформировать...

Дан массив D(12). Сформировать новый массив из положительных кратных 3 чисел исходного
D(12) для более лёгкой проверки я сделал massiv. Я не знаю почему первым в massiv1 идёт 0 и не...

Сформировать массив размера N, содержащий степени двойки от первой до N-ой (проверьте код)
#include <stdio.h> #include <locale.h> int main(void) { int a; int n, i = 1;...

Сформировать новый массив из положительных нечетных элементов заданного массива Р
Сформировать новый массив из положительных нечетных элементов заданного массива Р (20). Использую...

14
stake-k26
662 / 458 / 350
Регистрация: 25.04.2016
Сообщений: 1,317
21.11.2017, 11:11 2
Давайте разберемся с тем, что такое массивы. Массивы - это такие штуки, которые позволяют хранить последовательность чисел.

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

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

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
 
int main()
{
    int a1;
    int a2;
    int a3;
    int a4;
 
    /* дадим пользователю подсказку */
    printf("Пожалуйста, введите 4 целых числа.\n");
 
    /* теперь получим от него 4 числа */
    printf("Введите первое число: ");
    scanf("%i", &a1);
 
    printf("Введите второе число: ");
    scanf("%i", &a2);
 
    printf("Введите третье число: ");
    scanf("%i", &a3);
 
    printf("Введите четвертое число: ");
    scanf("%i", &a4);
 
    /* а теперь напечатаем полученные числа задом наперед */
    printf("%i %i %i %i\n", a4, a3, a2, a1);
 
    return 0;
}
Понятно, что если чисел немного, например, 10, то это еще терпимо. А что если нам нужно получить от пользователя 50 чисел? Нам придется вводить в программу 50 переменных, 50 раз просить пользователя ввести числа, а потом еще и выводить эту колбасу из чисел на экран.

Например программа текстовый редактор может хранить строки текста разными способами, но удобнее всего это делать, выделив для каждой буквы свою переменную (например, для первой буквы - с1, для второй - с2 и т.д.). Этот способ так же подходит лишь если букв три или пять. А если их тысяча? Тогда анализировать текст, искать нужный текст, копировать блоки текста окажется очень трудным делом. Каждый раз придется с помощью огромного условного оператора, состоящего из тысяч команд else if, выяснять где же находится нужный кусок текста.

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

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

Массив описывается как обычная переменная, только после его имени в квадратных скобках дополнительно указывается число хранимых элементов. Допустим, нам нужно сформировать массив из ста целых чисел, это можно сделать так:

int m[100];

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

double d[15];

и так далее.

Отметим, что внутри массива, у каждой отдельной переменной-ячейки (элемента массива) есть свой порядковый номер. И для того, чтобы обратиться к конкретному элементу массива, считать его значение или записать в него другое число, нужно указать имя массива и в квадратных скобках номер нужного элемента. Например, если мы хотим использовать в вычислениях десятое число из нашего массива, мы можем написать так:

m[9]

Сразу же возникает вопрос, а почему мы пишем 9, ведь мы обращаемся к ДЕСЯТОМУ элементу? Важно учитывать, что нумерация элементов массива в си ВСЕГДА начинается с 0. Т.е. у массива есть не только первый элемент, но и нулевой, и отсчет начинается именно с него. Поэтому при записи int m[100] - памяти выделяется для хранения ровно ста элементов: от 0 до 99. Одна из наиболее распространенных ошибок при работе с массивами заключается именно в ошибочном определении адреса нужного элемента.

Для того, чтобы записать в пятый элемент нашего массива число 50, нужно использовать присваивание:

m[4] = 50;

Значение, которое хранится в любом элементе массива, можно вывести на экран. Точно так же, как и обычную переменную:

printf("пятый элемент равен: %i\n", m[4]);

И да, напоминаю, что в качестве индекса элемента массива может использоваться не только конкретное число, но и переменная, константа или какое-то выражение (даже значение из ячейки другого массива):

C
1
2
3
m[a]
m[i + 12]
m[2*x + a[d] - 1]
Теперь, зная все это, мы можем переписать нашу программу, используя массив и циклы:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
 
int main()
{
    int mlen = 4;       // число элементов массива
    int a[mlen];        // наш массив
    int i;              // счетчик цикла
 
    /* дадим пользователю подсказку */
    printf("Пожалуйста, введите %i целых числа.\n", mlen);
 
    /* теперь получим от него 4 числа */
    for(i=0; i<mlen; i++)
    {
        printf("Введите %d-е число: ", i+1);        // %d то же, что и %i
        scanf("%i", &a[i]);
    }
 
    /* а теперь напечатаем все числа задом наперед */
    for(i=mlen; i>0; i--)
    {
        printf("%i ", a[i-1]);
    }
    printf("\n");
 
    return 0;
}
Обратим внимание на цикл для печати. Почему при обращении к элементу массива мы вычитали единицу?

Не забывайте, что нумерация элементов массива начинается с 0. Поэтому при объявлении массива из четырех элементов, мы получили 4 переменных: a[0], a[1], a[2] и a[3], т.е. с индексами от 0 до mlen-1. Будьте внимательны!

Добавлено через 20 минут
Ваше задание в самом простом случае будет выглядеть так:
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
 
int main (void)
{
    int n, i, c;
    printf("n = "); scanf("%d", &n);
 
    // заполняем массив значениями:
    if (n>0)
    {
        int a[n];   // наш массив из n элементов
        for (i=0, c=1; i<n; i++, c+=2)
            a[i] = c;
    }
 
    return 0;
}
2
COKPOWEHEU
1327 / 960 / 220
Регистрация: 09.09.2017
Сообщений: 3,964
21.11.2017, 11:40 3
stake-k26, правда, в учебнике это, наверное, написано получше, есть логичная нить повествования, но все равно вы дали хорошее объяснение.
Цитата Сообщение от stake-k26 Посмотреть сообщение
Ваше задание в самом простом случае будет выглядеть так:
Вывод забыли сделать, но, надеюсь, тут ТС справится
1
stake-k26
662 / 458 / 350
Регистрация: 25.04.2016
Сообщений: 1,317
21.11.2017, 12:05 4
Цитата Сообщение от COKPOWEHEU Посмотреть сообщение
Вывод забыли сделать
Ага, спасибо. Я уже как-то задним числом подумал, что на экране ничего не будет:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
 
int main (void)
{
    int n, i, c;
    printf("n = "); scanf("%d", &n);
 
    // заполняем массив значениями:
    if (n>0)
    {
        int a[n];   // наш массив из n элементов
        for (i=0, c=1; i<n; i++, c+=2)
        {
            a[i] = c;
            printf("%-3d", a[i]);   // выводим значение на экран
        }
        printf("\n");
    }
 
    return 0;
}
0
21.11.2017, 12:05
Байт
Эксперт C
20455 / 12984 / 2729
Регистрация: 24.12.2010
Сообщений: 27,168
21.11.2017, 12:57 5
stake-k26, Класс!
0
COKPOWEHEU
21.11.2017, 12:59
  #6

Не по теме:

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

0
Байт
Эксперт C
20455 / 12984 / 2729
Регистрация: 24.12.2010
Сообщений: 27,168
21.11.2017, 13:11 7
Цитата Сообщение от COKPOWEHEU Посмотреть сообщение
форум все-таки не место для цитирования учебника.
Почему? Ведь учебников никто не читает (как и правил) А тут - сел обедать - тебе и ложку в руки.
А главное, что автор этого трактата, уважаемый stake-k26, видимо, с удовольствием провел время
0
stake-k26
662 / 458 / 350
Регистрация: 25.04.2016
Сообщений: 1,317
21.11.2017, 13:17 8
У автора накопилось куча материалов, когда-то написанных, так что все написание ушло в ctrl+c ctl+v. Главу из учебника не могу указать, поскольку я еще не садился писать такой учебник:

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

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

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

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
 
int main()
{
    int a1;
    int a2;
    int a3;
    int a4;
 
    /* дадим пользователю подсказку */
    printf("Пожалуйста, введите 4 целых числа.\n");
 
    /* теперь получим от него 4 числа */
    printf("Введите первое число: ");
    scanf("%i", &a1);
 
    printf("Введите второе число: ");
    scanf("%i", &a2);
 
    printf("Введите третье число: ");
    scanf("%i", &a3);
 
    printf("Введите четвертое число: ");
    scanf("%i", &a4);
 
    /* а теперь напечатаем полученные числа задом наперед */
    printf("%i %i %i %i\n", a4, a3, a2, a1);
 
    return 0;
}
Понятно, что если чисел немного, например, 10, то это еще терпимо. А что если нам нужно получить от пользователя 50 чисел? Нам придется вводить в программу 50 переменных, 50 раз просить пользователя ввести числа, а потом еще и выводить эту колбасу из чисел на экран.

Например программа текстовый редактор может хранить строки текста разными способами, но удобнее всего это делать, выделив для каждой буквы свою переменную (например, для первой буквы - с1, для второй - с2 и т.д.). Этот способ так же подходит лишь если букв три или пять. А если их тысяча? Тогда анализировать текст, искать нужный текст, копировать блоки текста окажется очень трудным делом. Каждый раз придется с помощью огромного условного оператора, состоящего из тысяч команд else if, выяснять где же находится нужный кусок текста.

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

Массивы - важнейшее понятие в программировании. В массивах хранят и обрабатывают (как правило с помощью циклов) наборы однотипной информации.

Массив описывается как обычная переменная, только после его имени в квадратных скобках дополнительно указывается число хранимых элементов. Допустим, нам нужно сформировать массив из ста целых чисел, это можно сделать так:

int m[100];

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

double d[15];

и так далее.

Отметим, что внутри массива, у каждой отдельной переменной-ячейки (элемента массива) есть свой порядковый номер. И для того, чтобы обратиться к конкретному элементу массива, считать его значение или записать в него другое число, нужно указать имя массива и в квадратных скобках - номер нужного элемента. Например, если мы хотим использовать в вычислениях десятое число из нашего массива, мы можем написать так:

m[9]

Сразу же возникает вопрос, а почему мы пишем 9, ведь мы обращаемся к ДЕСЯТОМУ элементу? Важно учитывать, что нумерация элементов массива в си ВСЕГДА начинается с 0. Т.е. у массива есть не только первый элемент, но и нулевой, и отсчет начинается именно с него. Поэтому при записи int m[100] - памяти выделяется для хранения ровно ста элементов: от 0 до 99. Одна из наиболее распространенных ошибок при работе с массивами заключается именно в ошибочном определении адреса нужного элемента.

Для того, чтобы записать в пятый элемент нашего массива число 50, нужно использовать присваивание:

m[4] = 50;

Значение, которое хранится в любом элементе массива, можно вывести на экран. Точно так же, как и обычную переменную:

printf("пятый элемент равен: %i\n", m[4]);

И да, напоминаю, что в качестве индекса элемента массива может использоваться не только конкретное число, но и переменная, константа или какое-то выражение (даже значение из ячейки другого массива или полученное из внешней функции):

C
1
2
3
4
m[a]
m[i + 12]
m[2*x + a[d] - 2]
m[strlen(s) - i]
Теперь, зная все это, мы можем переписать нашу программу, используя массив и циклы:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
 
int main()
{
    int mlen = 4;       // число элементов массива
    int a[mlen];        // наш массив
    int i;              // счетчик цикла
 
    /* дадим пользователю подсказку */
    printf("Пожалуйста, введите %i целых числа.\n", mlen);
 
    /* теперь получим от него 4 числа */
    for(i=0; i<mlen; i++)
    {
        printf("Введите %d-е число: ", i+1);        // %d то же, что и %i
        scanf("%i", &a[i]);
    }
 
    /* а теперь напечатаем все числа задом наперед */
    for(i=mlen; i>0; i--)
    {
        printf("%i ", a[i-1]);
    }
    printf("\n");
 
    return 0;
}
Обратим внимание на цикл для печати. Почему при обращении к элементу массива мы вычитали единицу?

Не забывайте, что нумерация элементов массива начинается с 0. Поэтому при объявлении массива из четырех элементов, мы получили ровно 4 переменных: a[0], a[1], a[2] и a[3], т.е. с индексами от 0 до mlen-1. Будьте внимательны!

Мы познакомились с массивами и научились их объявлять и выводить элементы массива на экран. Но фактически никаких действий с отдельными элементами массивов мы не выполняли.

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

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

Например, проверим, есть ли в массиве число 10:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
 
int main()
{
    int mlen = 4;       // число элементов массива
    int a[mlen];        // наш массив
    int i;              // счетчик цикла
    int b = 10;         // число, которое будем искать
 
    /* дадим пользователю подсказку */
    printf("Пожалуйста, введите %i целых числа.\n", mlen);
 
    /* теперь получим от него 4 числа */
    for(i = 0; i < mlen; i++)
    {
        printf("Введите %d-е число: ", i + 1);      // %d то же, что и %i
        scanf("%i", &a[i]);
    }
 
    /* проверим, есть ли в массиве число 10 */
    for(i = 0; i < mlen; i++)
    {
        if(a[i] == b)
        {
            printf("Мы нашли число %d!\n", b);
        }
    }
 
    return 0;
}
Обратим внимание на строку if(a[i] == b) именно в таких случаях возникает вторая самая распространеная ошибка при работе с массивами. Если написать if(a[i] = b), то си не заметит подвоха, но эта запись перепишет все ячейки массива значением b.

Как это происходит? Как и любое другое выражение в си, условие выполняется справа налево, т.е. сначала компьютер выполнит все, что записано в скобках, и только потом выполнит операцию сравнения. А что у нас записано скобках? А в скобках мы присваиваем ячейке a[i] значение b. Да, мы хотели сравнить два значения, но поторопились и вместо "==" написали "=". По сути у нас получится следующее:

a[i] = b;
if (a[i]) { printf("Мы нашли число %d!\n", b); }

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

До сих пор мы использовали массивы заданного размера, однако бывают ситуации, когда размер массива нам заранее неизвестен. В этом случае есть несколько возможных решений:
1. Сначала определить размер массива, а затем объявить массив заданного размера.
2. Объявить массив достаточно большого размера, но использовать только его часть.
3. Задать массив неизвестного размера и определять его размер по мере необходимости.

Разберем первый случай.

Например, мы спрашиваем пользователя каким будет размер массива, затем объявляем массив заданного размера и просим пользователя ввести значения элементов массива:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <stdio.h>
 
int main(void)
{
    int size = 0;   // размер массива
    int i;          // счетчик цикла
 
    /* просим пользователя указать размер массива */
    printf("Укажите размер массива:\n");
    while(size < 1)
    {
        scanf("%i", &size);
    }
 
    /* задаем массив нужного размера */
    int a[size];
 
    /* просим ввести элементы массива */
    for(i = 0; i < size; i++)
    {
        printf("Введите %i-е число: ", i + 1);
        scanf("%i", &a[i]);
    }
 
    /* выводим массив на экран */
    for(i = 0; i < size; i++)
    {
        if(i > 0 && i%39 == 0)
        {
            printf("%i\n", a[i]);
        }
        else
        {
            printf("%i ", a[i]);
        }
    }
    printf("\n");
 
    return 0;
}
В чем минусы такого способа? Ну, самым главным минусом, пожалуй, является то, что массив объявляется где-то внутри программы, из-за этого читать код неудобно, кроме того, если программа достаточно длинная и сложная, легко потерять то место, где мы объявляем массив, из-за чего затрудняется процесс отладки.

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

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

Теперь рассмотрим второй случай.

Напишем точно такую же программу, но сразу зададим массив размером в 1000 ячеек.

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
 
int main(void)
{
    int a[1000];    // массив
    int size = 0;   // размер массива
    int i;          // счетчик цикла
 
    /* просим пользователя указать размер массива */
    printf("Укажите размер массива:\n");
    while(size < 1)
    {
        scanf("%i", &size);
    }
 
    /* просим ввести элементы массива */
    for(i = 0; i < size; i++)
    {
        printf("Введите %i-е число: ", i + 1);
        scanf("%i", &a[i]);
    }
 
    /* выводим массив на экран */
    for(i = 0; i < size; i++)
    {
        if(i > 0 && i%39 == 0)
        {
            printf("%i\n", a[i]);
        }
        else
        {
            printf("%i ", a[i]);
        }
    }
    printf("\n");
 
    return 0;
}
Сразу же становится ясно, что главным минусом такого способа является неэффективное использование оперативной памяти. Мы всегда задаем массив в 1000 ячеек, и если пользователю нужен массив всего в 6 ячеек, то 994 ячейки у нас лежат мертвым грузом и просто занимают место в оперативной памяти.

Рассмотрим третий случай.

На примере все той же программы:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int* a;         // заготовка массива
    int size = 0;   // размер массива
    int i;          // счетчик цикла
 
    /* просим пользователя указать размер массива */
    printf("Укажите размер массива:\n");
    while(size < 1)
    {
        scanf("%i", &size);
    }
 
    /* задаем размер массива достаточный для хранения size целых чисел */
    a = (int *)malloc(size * sizeof(int));
    
    /* просим ввести элементы массива */
    for(i = 0; i < size; i++)
    {
        printf("Введите %i-е число: ", i + 1);
        scanf("%i", &a[i]);
    }
 
    /* выводим массив на экран */
    for(i = 0; i < size; i++)
    {
        if(i > 0 && i%39 == 0)
        {
            printf("%i\n", a[i]);
        }
        else
        {
            printf("%i ", a[i]);
        }
    }
    printf("\n");
 
    free(a);            // освобождаем память, занятую массивом
    return 0;       // выходим из программы
}
Как нетрудно заметить, этот вариант практически ни чем не отличается от первого, за исключением того, что мы используем дополнительную библиотеку stdlib.h и совершенно непонятную строчку:

a = (int *) malloc(size * sizeof(int));

В этой строке:
sizeof(int) - определяет какой размер оперативной памяти отводится для хранения данных типа int в операционной системе.

malloc(size * sizeof(int)) - мы просим компьютер выдать нам столько памяти, сколько будет достаточно для хранения size чисел, с учетом того, что для хранения каждого числа требуется sizeof(int) оперативной памяти.

И после всего этого, мы говорим, что "a" будет занимать вот столько (size * sizeof(int)) оперативной памяти.

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

Это профессиональный способ объявления массивов, и у него есть куча плюсов, но в то же время он самый опасный, поскольку при каждом обращении к функциям malloc, alloc и realloc могут возникать ошибки выделения памяти и их нужно отслеживать! Плюс постоянно приходится держать в голове, что массив объявлен и перед выходом из программы нужно освободить занятую им память. Для чего используется функция free().

Есть еще четвертый способ, когда мы не знаем сколько у нас значений, т.е. мы выделяем память под массив динамически. Как это происходит? Мы получаем с клавиатуры число, рассчитываем размер массива, если это первый раз, то используем malloc, если это второй-третий-десятый раз, используем realloc для выделения памяти по размеру массива. При этом каждый раз следим, что компьютер выдал нам память без ошибок. И в конце перед выходом из программы используем free() для освобождения памяти.

Посмотрим на этот способ на примере функции, считывающей с клавиатуры строку символов:

C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char * get_string (void);           // строка с клавиатуры
 
int main (void)
{
    char * str = get_string();      //получаем строку символов
    printf ("%s\n", str);           //печатаем строку символов
    exit(0);
}
// --------------- получаем строку с клавиатуры ---------------
// ------------------------------------------------------------
char * get_string (void)
{
    char * buffer = NULL;               //буфер для хранения символов
    unsigned int capacity = 0;          //размер буфера
    unsigned int n = 0;                 //сколько символов в буфере
    int bitofchar = sizeof(char);       //сколько бит в char
    int MAX_LEN = 2048;                 //одна строка максимум 4 Мб (MAX_LEN*2)
    int c;                                  //сюда записываем символы
    // получаем символы со стандартного ввода (клавиатура или файл)
    while ((c = fgetc(stdin)) != '\n' && c != EOF)
    {
        // при необходимости увеличиваем размер буфера
        if (n+1 > capacity)
        {
            if (!capacity)                      //если буфера нет: if (capacity == 0)
                capacity = 32;                  //задаем новый, по умолчанию 32 символа
            else if (capacity <= MAX_LEN)
                capacity *= 2;                  //если размер исчерпан, удваиваем
            else                                    //иначе (угроза переполнения буфера):
            {                                       //освобождаем память и выходим
                free(buffer);
                return NULL;
            }
            // меняем реальный размер буфера в памяти
            char * temp = (char *) realloc(buffer, capacity * bitofchar);
            if (!temp)                          //if (temp == NULL)
            {
                free(buffer);
                return NULL;
            }
            buffer = temp;                      //перезаписываем буфер
        }
        buffer[n++] = c;                        //добавляем текущий символ в буфер
    }
    // если пользователь ввел пустую строку, возвращаем NULL
    if (n == 0 && c == EOF) return NULL;
    // минимизируем размер буфера
    char * minimal = (char *) malloc((n + 1) * bitofchar);
    strncpy(minimal, buffer, n);
    free(buffer);
 
    minimal[n] = '\0';  //добавляем конец строки
    return minimal;     //возвращаем получившуюся строку
}
Мы не знаем сколько символов нам поступит с клавиатуры, поэтому выделяем память под массив что называется прямо по ходу дела. И в общем-то это все, что нужно знать о массивах.
2
COKPOWEHEU
1327 / 960 / 220
Регистрация: 09.09.2017
Сообщений: 3,964
21.11.2017, 13:45 9
Цитата Сообщение от Байт Посмотреть сообщение
Почему? Ведь учебников никто не читает (как и правил) А тут - сел обедать - тебе и ложку в руки.
Все-таки есть разница послать читать учебник или указать точное место.
Цитата Сообщение от stake-k26 Посмотреть сообщение
У автора накопилось куча материалов, когда-то написанных, так что все написание ушло в ctrl+c ctl+v. Главу из учебника не могу указать, поскольку я еще не садился писать такой учебник:
Воу-воу, не надо его полностью сюда цитировать!
Лучше действительно оформить в виде учебника или статьи и давать на нее ссылку.
0
stake-k26
662 / 458 / 350
Регистрация: 25.04.2016
Сообщений: 1,317
21.11.2017, 13:49 10
Цитата Сообщение от COKPOWEHEU Посмотреть сообщение
Воу-воу, не надо его полностью сюда цитировать!
Так я весь и не цитировал. Это без указателей, смещений адресов ... в общем без внутренней кухни устройства массивов. Ну и без заданий, конечно же. Автор изначально написал, что не разобрался с массивами, поэтому я и скинул ему самый минимум, который позволит хотя бы по форуму плавать спокойно и не пугаться всяких страшных конструкций.
0
Байт
Эксперт C
20455 / 12984 / 2729
Регистрация: 24.12.2010
Сообщений: 27,168
21.11.2017, 13:58 11
stake-k26, А мне нравится! Правда, до конца не дочел. Первые 50 строк еще читал, а дальше - по диагонали.
Разжевано все до манной каши. Остается только открыть рот и глотать. Но, с другой стороны, как проглотить такую массу?
0
COKPOWEHEU
1327 / 960 / 220
Регистрация: 09.09.2017
Сообщений: 3,964
21.11.2017, 14:32 12
Так я и говорю: оформите это в виде учебника или статьи. Или хотя бы блога на этом же форуме.
0
stake-k26
662 / 458 / 350
Регистрация: 25.04.2016
Сообщений: 1,317
21.11.2017, 14:36 13
Байт, так для этого в нормальных учебниках задания есть. Ты вроде как получил часть информации, а потом решаешь задачки, которые с одной стороны закрепляют материал, а с другой как раз и разбивают объем информации на части. Например, в оригинале на одно введение, которое я написал в начале, было 9 задач. Остальные темы на вскидку еще задач 30. Может даже чуть больше.

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

Добавлено через 2 минуты
Цитата Сообщение от COKPOWEHEU Посмотреть сообщение
Так я и говорю: оформите это в виде учебника или статьи.
Была уже такая мысль, но пока руки не доходят.
1
Kukstyler
21.11.2017, 18:05
  #14

Не по теме:

Имхо, можно создать тему, отдельно, и туда писать. Думаю, Админы прикрепят (Важное), и она будет всегда на виду.

0
Байт
Эксперт C
20455 / 12984 / 2729
Регистрация: 24.12.2010
Сообщений: 27,168
21.11.2017, 18:47 15
stake-k26, все правильно. И только удачи вам хочется вам пожелать!
Кто-то может сказать - "Но ведь уже столько написано на эту тему!" Но это все равно, что пенять Лермонтову - "Зачем ты писал Демона, если уже есть Евгений Онегин? Ведь и то, и другое - стихи"
Есть непростое явление природы. В случае с классиками - ЖИЗНЬ. В вашем случае - МАССИВЫ. И чтобы осмыслить эти явления, неплохо посмотреть на них с разных сторон.
0
21.11.2017, 18:47
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
21.11.2017, 18:47

Сформировать массив из первых 20 чисел Фибоначчи
Количество элементов массива ввести с клавиатуры, после чего выделить необходимый объем...

Сформировать массив с первых n простых чисел натурального числового ряда
сформировать массив с первых n простых чисел натурального числового ряда. простым считается число,...

Определить массив первых 196 натуральных нечетных чисел, не кратных трем, и распечатать его в виде матрицы
Здравствуйте. Помогите пожалуйста с задачкой. &quot;Определить массив первых 196 натуральных...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
15
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.
Рейтинг@Mail.ru