double difftime ( time_t time2, time_t time2 )

2019-11-13

188

Обсуждений (0)

0.00 из 5.00 0 оценок

⇐ Предыдущая 1 23

Функция diff time возвращает разность time2 - timel, выраженную в секундах

time_t mktime ( struct tm *tp )

Функция mktime преобразует местное время, заданное структурой *tp, в календарное и возвращает его в том же виде, что и функция time. Компоненты структуры будут иметь значения в указанных выше диапазонах. Функция возвращает календарное время или -1, если оно не представимо

char *asctime ( const struct tm *tp )

Функция asctime преобразует время из структуры *tp в строку вида: Sun Jan 3 15:14:13 1988\n\0

char *ctime ( const time_t *tp )

Функция сtime преобразует календарное время в местное, что эквивалентно вызову функции asctime (localtime (tp) )

struct tm *gmtime ( const time_t *tp )

Функция gmtime преобразует календарное время в так называемое "скоординированное универсальное время" (Coordinated Universal Time— UTQ). Она возвращает NULL, если UTC не известно. Имя этой функции сложилось исторически и означает Greenwich Mean Time (среднее гринвичское время)

struct tm *localtime ( const time_t *tp )

Функция localtime преобразует календарное время *tp в местное

size_t strftime ( char *s, size_t smax, const char *fmt, const struct tm *tp )

Функция strftime форматирует информацию о дате и времени из *tp и помещает ее в строку s согласно строке формата fmt, аналогичной той, которая используется в функции printf. Обычные символы (включая завершающий символ ‘\0’) копируются в s. Каждая пара, состоящая из % и буквы, заменяется, как описано ниже, с использованием значений по форме, соответствующей конкретной культурной среде. В строку s помещается не более smax символов. Функция возвращает количество символов без учета ‘\0’ или нуль, если число сгенерированных символов больше smax.

% a – сокращенное название дня недели

% A – полное название дня недели

% b – сокращенное название месяца

% B – полное название месяца

% c – местное представление даты и времени

% d – день месяца (01-31)

% H – час (по 24-часовому времени) (00-23)

% I – час (по 12-часовому времени) (01-12)

% j – день от начала года (001-366)

% m – месяц (01-12)

% M – минута (00-59)

% p – местное представление времени до и после полудня (AM и PM)

% S – секунда (00-61)

% U – неделя от начала года (считая первым днем недели воскресенье) (от 00 до 53)

% w – день недели (0 - 6, номер воскресенья равен 0)

% W – номер недели от начала года (считая первым днем недели понедельник) (от 00 до 53)

%x – местное представление даты

% X – местное представление времени

% y – год без указания века (00-99)

% Y – год с указанием века

% Z – название часового пояса, если есть

%% – символ %

< limits . h > и < float . h > – здесь определены константы и размеры чисел (стандарт вводит требования к минимальному диапазону числовых типов и регламентирует обязательное наличие заголовочных файлов <limits.h> и < float. h> с характеристиками конкретных реализаций)

CHAR_BIT – 8 – битов в char

SCHAR_MAX – UCHAR_MAX ИЛИ SCHAR_MAX – максимальное значение char

CHAR _ MIN – 0 или ИЛИ CHAR_MIN – минимальное значение char

INT _ MAX – +32767 – максимальное значение int

INT _ MIN – -32767 – минимальное значение int

LONG _ MAX – +2147483647 – максимальное значение long

LONG _ MIN – -2147483647 – минимальное значение long

SCHAR _ MAX – +127 – максимальное значение signed char

SCHAR _ MIN – -127 – минимальное значение signed char

SHRT _ MAX – +32767 – максимальное значение short

SHRT _ MIN – -32767 – минимальное значение short

UCHAR _ MAX – 255 – максимальное значение unsigned char

UINT _ MAX – 65535 – максимальное значение unsigned int

ULONG _ MAX – 4294967295 – максимальное значение unsigned long

USHRT _ MAX – 65535 – максимальное значение unsigned short

Константы для использовании в арифметике с плавающей точкой (имена с префиксом FLT относятся к величинам типа float, а с префиксом DBL – к величинам типа double):

FLT _ RADIX – 2 – основание для экспоненциальной формы представления, например 2,16

FLT _ ROUNDS – – режим округления при сложении чисел с плавающей точкой

FLT _ DIG – 6 – точность (количество десятичных цифр)

FLT _ EPSILON – 1E-5 – наименьшее число х такое, что 1.0 + x не равно 1.0

FLT _ MANT _ DIG – – количество цифр по основанию FLT_RADIX в мантиссе

FLT _ MAX – 1E+37 – наибольшее число с плавающей точкой

FLT _ MAX _ EXP – – наибольшее n такое, что FLT_RADIX^n-1 представимо

FLT _ MIN – 1E-37 – наименьшее нормализованное число с плавающей точкой

FLT _ MIN _ EXP – – наименьшее n, такое, что 10^n - нормализованное число

DBL _ DIG – 10 – количество значащих десятичных цифр

DBL _ EPSILON – 1E-9 – наименьшее число x, такое, что 1.0 + х не равно 1.0

DBL _ MANT _ DIG – – количество цифр по основанию FLT_RADIX в мантиссе

DBL _ MAX – 1E+37 – наибольшее число с плавающей точкой

DBL _ MAX _ EXP – – наибольшее n, такое, что FLT_RADIX^n-1 представимо

DBL _ MIN – 1E-37 – наименьшее нормализованное число с плавающей точкой

DBL _ MIN _ EXP – – наименьшее n, такое, что 10^n - нормализованное число

От теории к практике

Изучив всё вышеизложенное, попробуем написать свою собственную маленькую программку, которая будет складывать или умножать два целых числа от 0 до 9. Можно было бы и что-нибудь сложнее уже написать, но для наглядности будем использовать то, что до этого мы изучили.

Итак, первое, что надо сделать – это поставить конкретную задачу: нам нужно ввести два числа и выбрать, сложить или перемножить их.

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

В принципе, порядок действий прост и понятен:

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

- во втором варианте: мы сначала выбираем, что мы будем делать – складывать или умножать, а уж потом вводим по очереди два числа и производим над ними арифметическое действие, в конце – так же выводим результат выполненной математической операции

Теперь воспользуемся преимуществом объектно-ориентированного языка программирования, коим Си и является. Будем считать, что каждое наше действие – это отдельная функция, т.е. мы можем отдельно ввести одно число, потом отдельно ввести второе число, потом отдельно посчитать результат и т.д., а каждая отдельная функция – это отдельная подпрограмма, хотя… можно вынести и в отдельную программу или библиотеку, но при таком минимализме нашей программы – это ни к чему. Раз уж у нас отдельные функции, давайте придумаем им имена, причём, лучше по смыслу выполняемой операции, чтоб привыкнуть и при написании больших программ, не путаться, что и где, а понимать по смыслу. В общем, у меня получилось так:

Вы спрашиваете, а где же main? А всё оригинальное – просто! main у меня – это начало и конец, а так же – управление алгоритмом.

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

- переменная a

- переменная b

- и полученный результат вычислений, назовём: resultat_ab

Можно все эти три переменные объявить на весь проект, в самом начале:

---------------------------------------------------------------------------------------------------------------------------------------------

int a;

int b;

int resultat_ab;

---------------------------------------------------------------------------------------------------------------------------------------------

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

---------------------------------------------------------------------------------------------------------------------------------------------

summa_ab ( a, b ) /* объявляем функцию summa_ab и т.к. нам надо будет вводить в эту функцию данные, в скобках указываем переменные для ввода в эту функцию; эти переменные у нас уже объявлены на весь проект */

{

return ( a + b ); /* здесь оператор return – это не математический оператор, return всего лишь позволяет передать правильно рассчитанное значение данной функции в то место, откуда её вызвали, а в скобках мы производим математическую операцию сложения */

}

---------------------------------------------------------------------------------------------------------------------------------------------

Теперь, давайте, по аналогии со сложением, напишем умножение:

---------------------------------------------------------------------------------------------------------------------------------------------

proisvedenie_ab ( a, b ) /* объявляем функцию proisvedenie_ab и т.к. нам надо будет вводить в эту функцию данные, в скобках указываем переменные для ввода в эту функцию; эти переменные у нас уже объявлены на весь проект */

{

return ( a * b ); /* здесь оператор return – это не математический оператор, return всего лишь позволяет передать правильно рассчитанное значение данной функции в то место, откуда её вызвали, а в скобках мы производим математическую операцию умножения */

}

---------------------------------------------------------------------------------------------------------------------------------------------

Так же, достаточно просто написать вывод результата вычисления и так как мы будем использовать стандартную библиотечную функцию printf для вывода результата, не забудем здесь задействовать stdio.h, но не в теле функции, а перед ней. Если бы мы использовали printf где-нибудь ещё, то второй раз вызывать заголовочный stdio.h больше бы не понадобилось (если это один программный файл). А вообще, правилом хорошего тона считается помещение всех объявляемых заголовочных файлов вверху, в самом начале листинга программы. Что-то я отвлёкся… и так, вывод результата:

---------------------------------------------------------------------------------------------------------------------------------------------

#include <stdio.h>

print_result ( resultat_ab ) /* объявляем функцию print_result и т.к. нам надо будет вводить в эту функцию данные, в скобках указываем переменную для ввода в эту функцию; эта переменная у нас уже объявлены на весь проект */

{

printf ( “Resultat:\t%d\n”, resultat_ab ); /* выводим результат вычисления в терминал */

return 0; /* корректно завершаем выполнение функции, возвращая ноль */

}

---------------------------------------------------------------------------------------------------------------------------------------------

Напишем ввод чисел, для этого нам понадобится подключить тот же стандартный заголовочный файл stdio.h, что мы подключили уже выше и поэтому мы не будем добавлять в код: #include <stdio.h>. Из этой стандартной библиотеки мы будем использовать стандартные функции ввода и вывода – getchar и putchar, соответственно. И так:

---------------------------------------------------------------------------------------------------------------------------------------------

vvod_a ()

{

printf ( “Enter a and press Enter, a=” );

a = getchar ();

return a;

}

---------------------------------------------------------------------------------------------------------------------------------------------

Вот теперь самое интересное: функция getchar возвращает в нашем случае некий код, а не введённые цифры – это получается из-за неправильного объявления типа переменной (мы в начале объявили int a и int b, а надо было объявить char a и char b) для функции getchar. Наверное, можно воспользоваться какой-нибудь другой стандартной библиотечной функцией, но, допустим…мы, пока, не знаем какой – язык-то только начинаем изучать. Можно было бы и объявить char, но нам-то надо считать десятичные цифры, а не числа в байтах. Ещё можно правильно объявить getchar: вместо a = getchar (); записать – int a = getchar ();, но наша цель показать, как из-за мелочей меняются значения, возвращаемые функцией. Поэтому мы пойдём по неправильному пути – всё это неверно, но работать будет и мы просто напишем свой простенький конвертор, в придачу к предсказуемым, но неверно возвращаемым значениям функции getchar (что-то уж больно мне эти значения ASCII-код клавиатуры напоминают):

---------------------------------------------------------------------------------------------------------------------------------------------

convertor ( int x ) /* здесь мы «x», принадлежащий этой функции в качестве входного параметра, мы объявили «x» явно, прямо здесь */

{

if ( x == 48 ) x = 0; /* если символ равен 48, то это цифра 1 */

else if ( x == 49 ) x = 1; /* иначе, если символ равен 49, то это цифра 2 */

else if ( x == 50 ) x = 2; /* иначе, если символ равен 50, то это цифра 1 */

else if ( x == 51 ) x = 3; /* иначе, если символ равен 51, то это цифра 1 */

else if ( x == 52 ) x = 4; /* иначе, если символ равен 52, то это цифра 1 */

else if ( x == 53 ) x = 5; /* иначе, если символ равен 53, то это цифра 1 */

else if ( x == 54 ) x = 6; /* иначе, если символ равен 54, то это цифра 1 */

else if ( x == 55 ) x = 7; /* иначе, если символ равен 55, то это цифра 1 */

else if ( x == 56 ) x = 8; /* иначе, если символ равен 56, то это цифра 1 */

else if ( x == 57 ) x = 9; /* иначе, если символ равен 57, то это цифра 1 */

else /* иначе, если ничего не совпадает выполняем операторы в фигурных скобках */{

printf ( "\nERROR\n" ); /* выводим надпись об ошибке */

x = 0; /* считаем, что ввели ноль (приравниваем введённую цифру к нулю) */

}

return x;

}

---------------------------------------------------------------------------------------------------------------------------------------------

Ещё функция getchar возвращает нам и нажатую клавишу Enter – значит нам надо обнулить getchar и самый простой способ – это вызвать эту функцию ещё раз. И с учётом этого и вновь появившейся функции convertor, перепишем vvod_a:

---------------------------------------------------------------------------------------------------------------------------------------------

vvod_a ()

{

printf ( “Enter a and press Enter, a=” );

a = getchar ();

getchar ();

a = convertor ( a );

return a;

}

---------------------------------------------------------------------------------------------------------------------------------------------

И, соответственно, vvod_b:

---------------------------------------------------------------------------------------------------------------------------------------------

vvod_b ()

{

printf ( “Enter b and press Enter, b=” );

b = getchar ();

getchar ();

b = convertor ( b );

return b;

}

---------------------------------------------------------------------------------------------------------------------------------------------

Теперь приступим к написанию выбора действия:

---------------------------------------------------------------------------------------------------------------------------------------------

vybor_deistviya ()

{

int x;

printf ( “\nEnter 1 or 2 and press Enter:\n1. a+b\n2. a*b\n ”);

x = getchar ();

getchar ();

if ( x == 49 ) x = 1; /* если символ равен 49, то это цифра 1 */

else if ( x == 50 ) x = 2; /* иначе, если символ равен 50, то это цифра 2 */

else /* иначе, если ничего не совпадает выполняем операторы в фигурных скобках */{

printf ( "\nERROR\n" ); /* выводим надпись об ошибке */

x = 1; /* считаем, что ввели ноль (приравниваем введённую цифру к нулю) */

}

return x;

}

---------------------------------------------------------------------------------------------------------------------------------------------

Теперь нам осталось написать нашу управляющую всем этим «хозяйством» функцию main. Здесь всё по порядку, как в алгоритме – сверху-вниз; не забыли наш алгоритм?

Вариант 1:

1. вызываем функцию vvod_a

2. вызываем функцию vvod_b

3. вызываем функцию vybor_deistviya

4. в зависимости от vybor_deistviya, вызываем summa_ab или proisvedenie_ab

5. вызываем print_result

И так, вариант 2:

1. вызываем функцию vybor_deistviya

2. вызываем функцию vvod_a

3. вызываем функцию vvod_b

4. в зависимости от vybor_deistviya, вызываем summa_ab или proisvedenie_ab

5. вызываем print_result

Вариант 1:

---------------------------------------------------------------------------------------------------------------------------------------------

main ()

{

int x; /* объявляем дополнительную переменную «x», которая не имеет ни какого отношения к переменной «x» функции convertor */

a = vvod_a (); /* вызываем функцию vvod_a и приравниваем её результат к переменной a */

b = vvod_b (); /* вызываем функцию vvod_b и приравниваем её результат к переменной b */

x = vybor_deistviya (); /* вызываем функцию vybor_deistviya и приравниваем её результат к промежуточной переменной x */

if ( x == 1 ) resultat_ab = summa_ab ( a, b ); /* если выбрали сложение - вызываем функцию summa_ab */

else if ( x == 2 ) resultat_ab = proisvedenie_ab ( a, b ); /* если выбрали умножение - вызываем функцию proisvedenie_ab */

print_result ( resultat_ab ); /* вызываем функцию resultat_ab */

return 0;

}

---------------------------------------------------------------------------------------------------------------------------------------------

Вариант 2:

---------------------------------------------------------------------------------------------------------------------------------------------

main ()

{

x = vybor_deistviya (); /* вызываем функцию vybor_deistviya и приравниваем её результат к промежуточной переменной x */

a = vvod_a (); /* вызываем функцию vvod_a и приравниваем её результат к переменной a */

b = vvod_b (); /* вызываем функцию vvod_b и приравниваем её результат к переменной b */

if ( x == 1 ) resultat_ab = summa_ab ( a, b ); /* если выбрали сложение - вызываем функцию summa_ab */

else if ( x == 2 ) resultat_ab = proisvedenie_ab ( a, b ); /* если выбрали умножение - вызываем функцию proisvedenie_ab */

print_result ( resultat_ab ); /* вызываем функцию resultat_ab */

return 0;

}

---------------------------------------------------------------------------------------------------------------------------------------------

В итоге получаем (коментарии удалил, чтоб разные варианты сравнить можно было проще), слева – вариант 1, справа – вариант 2:

---------------------------------------------------------------------------------------------------------------------------------------------

int a; int a;

int b; int b;

int resultat_ab; int resultat_ab;

summa_ab ( a, b ) summa_ab ( a, b )

{ {

return ( a + b ); return ( a + b );

} }

proisvedenie_ab ( a, b ) proisvedenie_ab ( a, b )

{ {

return ( a * b ); return ( a * b );

} }

#include <stdio.h> #include <stdio.h>

print_result ( resultat_ab ) print_result ( resultat_ab )

{ {

printf ( “Resultat:\t%d\n”, resultat_ab ); printf ( “Resultat:\t%d\n”, resultat_ab );

return 0; return 0;

} }

convertor ( int x ) convertor ( int x )

{ {

if ( x == 48 ) x = 0; if ( x == 48 ) x = 0;

else if ( x == 49 ) x = 1; else if ( x == 49 ) x = 1;

else if ( x == 50 ) x = 2; else if ( x == 50 ) x = 2;

else if ( x == 51 ) x = 3; else if ( x == 51 ) x = 3;

else if ( x == 52 ) x = 4; else if ( x == 52 ) x = 4;

else if ( x == 53 ) x = 5; else if ( x == 53 ) x = 5;

else if ( x == 54 ) x = 6; else if ( x == 54 ) x = 6;

else if ( x == 55 ) x = 7; else if ( x == 55 ) x = 7;

else if ( x == 56 ) x = 8; else if ( x == 56 ) x = 8;

else if ( x == 57 ) x = 9; else if ( x == 57 ) x = 9;

else { else {

printf ( "\nERROR\n" ); printf ( "\nERROR\n" );

x = 0; x = 0;

} }

return x; return x;

} }

vvod_a () vvod_a ()

{ {

printf ( “Enter a and press Enter, a=” ); printf ( “Enter a and press Enter, a=” );

a = getchar (); a = getchar ();

getchar (); getchar ();

a = convertor ( a ); a = convertor ( a );

return a; return a;

} }

vvod_b () vvod_b ()

{ {

printf ( “Enter b and press Enter, b=” ); printf ( “Enter b and press Enter, b=” );

b = getchar (); b = getchar ();

getchar (); getchar ();

b = convertor ( b ); b = convertor ( b );

return b; return b;

} }

vybor_deistviya () vybor_deistviya ()

{ {

int x; int x;

printf ( “\nEnter 1 or 2 and press Enter:\n1. a+b\n2. a*b\n ”); printf ( “\nEnter 1 or 2 and press Enter:\n1. a+b\n2. a*b\n ”);

x = getchar (); x = getchar ();

getchar (); getchar ();

if ( x == 49 ) x = 1; if ( x == 49 ) x = 1;

else if ( x == 50 ) x = 2; else if ( x == 50 ) x = 2;

else { else {

printf ( "\nERROR\n" ); printf ( "\nERROR\n" );

x = 1; x = 1;

} }

return x; return x;

} }

main () main ()

{ {

int x; int x;

a = vvod_a (); x = vybor_deistviya ();

b = vvod_b (); a = vvod_a ();

x = vybor_deistviya (); b = vvod_b ();

if ( x == 1 ) resultat_ab = summa_ab ( a, b ); if ( x == 1 ) resultat_ab = summa_ab ( a, b );

else if ( x == 2 ) resultat_ab = proisvedenie_ab ( a, b ); else if ( x == 2 ) resultat_ab = proisvedenie_ab ( a, b );

print_result ( resultat_ab ); print_result ( resultat_ab );

return 0; return 0;

} }

---------------------------------------------------------------------------------------------------------------------------------------------

Как видно, все функции у нас абсолютно одинаковые, различие есть только в функции main. Можно, конечно, скомпилировать всё и в таком виде, но… не мешало бы привести весь текст программы в более удобочитаемый вид, например, для варианта 2, всё последовательно и понятно: