Программирование на чистом Си (без ++)

Пример:

double sum (double x, double y)
{
	double z = x + y;
	return z;
}

return x; - возврат значения

return; - немедленный выход из функции

тип = void - означает, что функция не возвращает значения.

аргументы = void - означает, что функция не получает никаких аргументов.

В конце функции-процедуры return можно не дописать (компилятор добавить автоматически)

Передача параметров в функции:

1) по значению - копирование содержимого аргумента в формальный параметр

2) по ссылке - копируется адрес аргумента,

Пример:

int f(int *x) {return *x;}
int y; 
f(&y); 

Прототип функции:

тип имя_функции (параметры);

исп-ся для определение типа возвращаемого значения, а также типа и числа аргументов. Обычно помещается в начале программы или в h-файлах.

Пример: double pow (double, double); // названия аргументов можно не указывать.

func(...) - если многоточие в прототипе, то кол-во аргументов не считается.

Возврат указателя из функции:

int *func(int x; return &x;)

Указатели на функции:

int (*f)(int, int);

Указатель на функцию - это адрес точки входа в соответствующую функцию.

double (*pf)(double);	 // объявление указателя на функцию (скобки обязательны) (можно локально)
pf = sin;  // присвоить указателю ссылку на конкретную функцию 
(*pf)(x);  // вызов функции по указателю

где pf - указатель на функцию, *pf - сама функция, а (*pf)(x) - обращение к этой функции.

pf(x);		// упрощенная форма
integral(0., 3.14, 20, pf);  или integral(0., 3.14, 20, sin);  //   передача имени функции как параметра в другую функцию:    
double integral(double a, double b, int n, double (*f)(double))  { f(a); или (*f)(a);}

Пример:

int func1(int x, int y) {return x*y;}  
f = func1;  
y=f(2,3);

Можно также использовать массив указателей на функции:

int f1(int x) {return 1*x;}
int (*mf[3])(int) = {f1, f2, f3};  
f = mf[0];  
f(3);  
mf[0](3);

При вызове функции в программый стек помещаются (в следующем порядке):

- 1) аргументы функции

- 2) адрес возврата (из функции)

- 3) локальные переменные

Массивы в Си

Массив в ОЗУ занимает непрерывный блок (без разрывов).

В C/C++ нумерация массива начинается с нуля: a[0] - 1-ый элемент, a[SIZE-1] - последний. В Си нет контроля выхода за пределы массива! Типичный цикл:

for(i=0; i < SIZE; ++i) { ... a[i] ... }

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

- Одномерный массив: тип имя_массива [размер];

тогда общее число байт = sizeof(тип)*размер

- Многомерный массив: тип имя_массива [размерN]...[размер2][размер1];

- с инициализацией: тип имя_массива [размерN]...[размер1] = {список значений};

пр.:

int m[3][2] = {a11, a12, a21, a22, a31, a32};  - матрица из 3 строк и 2 столбца

тоже самое что:

int m[3][2] = {{a11, a12}, {a21, a22}, {a31, a32}};  	// добавление скобок для красоты

В случае инициализации можно не указывать размер массива (посчитает автоматически):

int b[] = {1,2,3,4,5};
const int n = sizeof b / sizeof (int);	// узнать кол-во элементов, или
const int n = sizeof b / sizeof b[0];	// узнать кол-во элементов
сhar str[] = "hello";     
//или тоже самое:  
сhar str[6] = {'h','e','l','l','o','\n'};   

(строка - это массив типа char)

Передача массивов или строк в функцию:

func(char str[]);
int func(int array[][MAXLEN], int rows, int columns)

Индексация указателей:

a[j][k]  == *((тип *) a + (j*длина_строки) + k)

Имя массива есть адрес первого элемента массива!!! Примеры:

 &a[0][0]  == a;	
 &p[5]  == *(p+5);	// 6-ой элемент массива;
 double list[10], *ptr = list;
 list		// адрес элемента list[0]
 list + 1		// адрес элемента list[1] и т. д.  (автоматически масштабируется под размер типа)
 ptr	== &list[0];
 ptr + i	== &list[i]	 // - адрес list[i];
 *(ptr + i) == ptr[i] == list[i];		// ptr[i] - сокращенная запись

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

Пример.

double *p = list + 2;	// тогда p[0] = list[2]
p[-2];		// == list[0];

Передача массивов в функции.

Два способа:

1) с индексированием:

int func(int a[])  {   x = a[i];   }

2) с помощью указателя:

int func(int *a)  {    x = *a++;  y = *a;   }

3) комбинированные варианты:

int func(int a[])  {    x = *a;   }
int func(int *a)  {    x = a[i];   }

ОДНАКО между указателями и массивами есть 2 большие разницы:

- имя массива есть указатель-константа, т. е. нельзя изменить его значение;

- при определении массива под него резервируется блок памяти.

Указатель можно настроить на блок памяти 2-мя способами:

- под ранее выделенный блок памяти;

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

Динамические массивы

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

(здесь size_t - тип для измерения размера памяти для данной платформы).

void *malloc (size_t число_байт); - выделение памяти и возврат указателя типа void*; возвращает NULL в случае ошибки.

void *сalloc (size_t кол-во_блоков, size_t число_байт); - выделяет nitems*size байт и кроме того выполняется очистка памяти (обнуление).

void *realloc( void *block, size_t newsize ); - изменяет первоначальный размер выделенного блока (при необходимости осуществляется перенос данных в новое место в памяти).

void free (void *p); - возвращает выделенную память в кучу, где p - указатель на блок (важно, чтобы этот указатель был таким же как при выделении памяти! поэтому его желательно сделать const).

Пример:

extern int n;k
int *const p = malloc(n * sizeof(int));
if (!p) { ... }
for (i=0; i < n; i++) { p[i]; }
free(p);

Замечание про C++:

С++ (в отличии от С) не поддерживает автоматического преобразования типов. Поэтому в С++ надо:

	char *p;  p = (char *) malloc(1000);	// получение 1000 байт
	int *m; m = (int *) malloc(1000*sizeof(int));   // память под массив из 1000 чисел типа int

В С++ рекомендуется использовать new.

Строки как массивы

Примеры:

const char *p = "string";	

Здесь p - указатель на константную строку. Сама строка хранится в сигменте данных (read only). Слово const защищает от попытки записать в что-то в эту строку (иначе возможна ошибка при выполнении).

int main(int argc, const char *argv[], const char *env[])
//или тоже самое:    
int main(int argc, const char **argv, const char **env)
void strcopy(char *t, const char *s) { while(*t++ = *s++); }

Структуры, объединения, перечисления

Структуры (struct)

Описание (объявление структуры:

    struct date { char day; char mon; int year; } ;//	(после объявления точка с запятой!)

Определение структры, т. е. выделение памяти:

    struct data today;

Можно, но не рекомендуется (для больших проектов) совмещать описание и определение переменных:

   struct employee { int age;} emp, *pt=&emp;

Можно создать псевдоним

	typedef struct date date;

и затем писать короче:

	date today;
	

Или сразу с псевдонимом:

	typedef struct {char day, mon; int year;} date;

Определение с инициализацией:

	date birthday = {1, 4, 1980};

Доступ к элементам структуры - с помощью операции точка (.):

	today.day = 1;

Указатель на структуру:

	data *p = &today;

Доступ через указатель с помощью операции ( -> ):

p -> day     ==    (*p).day    ==  today.day;

Битовые поля

Битовое поле - это специальный тип структуры, который определяет, какой будет длина в битах каждого элемента структуры.

В С битовое поле может рассматриваться:

- как целое со знаком - signed int (по умолчанию просто int),

- или без знака - unsigned int.

Битовые поля длиной 1 должны объявляться как unsigned, поскольку 1 бит не может иметь знака.

struct имя структуры {
 тип имя1: длина;
 тип имя2: длина;
 ...
 тип имяN: длина;
 }
 

Пример:

struct fields 
{
	int i : 2;
	unsigned j : 5;
	int k : 1;
} a;

Объединения (union)

Предназначены для хранения нескольких переменных разных типов в (точнее совпадает адрес начала):

union pw { int i; char ch; }; 			// объявление объединения (в конце точка с запятой)
union pw wrd;				// объявление переменной
wrd.i = 10; wrd.ch = 'A';

Здесь выделяется 4 байта под pw, символ ch помещается в байт номер 0, int занимает 4 байта.

Перечисления (enum)

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

	enum имя {список_перечислений} список_переменных; 

По умолчанию, целые значения присваиваются элементам перечисления в возрастающем порядке, начиная с нуля. Имя не обязательно. Пример:

	enum Keyword {Q, W, E, R, T, Y};   // компилятор нумерует по порядку 0,1,2,...
	enum Keyword {Q=-1, W=2, E, R, T, Y};   // со своей нумерацией (не обязательно)
	enum Keyword key;	// создание переменной.
	key = T;
	if (key == T) cout << "key = T" << endl;

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

Препроцессор, директивы

Код обрабатывается препроцессором перед тем, как поступить на вход компилятора.

(C++ не рекомендует исп-ть препроцессор и предлагает более безопасный путь)

Директивы - команды препроцессора. Начинаются с символа # (заканчиваются переводом строки)

 #include	 // вставляет вместо этой строки текст всего файла.
 #include <имя_файла>	// стандарные хэдер-файлы
 #include "имя_файла"	// поиск в текущем проекте или по указанному пути, напр. "..\\..\\file.h"

Основные стандартные хэдер-файлы:

stdio.h - ф-ции ввода/вывода

stdlib.h - функции стандартной библиотеки (STL)

math.h - математические функции

limits.h и float.h - системно-зависимые значения

ctype.h , string.h , time.h , stdarg.h , locale.h - другие стандартные заголовочные файлы

conio.h - нестандартные функции работы с консолью

Макроопределения

 #define PI 3.14		// правило макроподстановки (рекомендуется большыми буквами)
 #define WIDTH 80
 #define LENGTH (WIDTH+10)
 #define MAX(x,y) ((x)>(y))?(x):(y)
 #define VAR(i,j) i##j		// склейка элементов - замена на ij
 #define SQR(x) x*x
 SQR(y-1);	// будет преобразовано в y-1*y-1
 //поэтому правильно
 #define SQR(x) (x)*(x)
 #undef идентификатор	// отмена макроопределения

В С++ (в отличии от С) константные переменные можно использовать для определения размера массива (позволяет избавиться от использования #define):

	const int size=10;
	int m[size];

#define TRACE(flag) printf(#flag "=%d\n",flag)
 
val = 1024;  TRACE(val);

Макросы и встраиваемые функции - сравнение:

 #define SOUNDERON()  PORTD.7=1
 inline void SounderON() {  PORTD.7 = 1; }

- результат тот же, но 2-ой вариант более современный для с++ (и удобнее).

Директивы условной компиляции:

 #if константное_выражение
 #ifdef идентификатор
 #ifndef идентификатор
 #elif константное_выражение
 #else
 #endif
 #if defined(symbol)    // эквивалентна  #ifdef symbol
 #if !defined(STUDENT_H) // эквивалентно #ifndef STUDENT_H

Защита от повторного включения хэдер-файла file.h!

 #ifndef FILE_H
 #define FILE_H
 // содержимое файла
 #endif

Другие директивы:

 #line номер_строки
 #error сообщение
 #pragma инструкция	// компилятор будет игнорировать директиву, если он не может распознать содержащуюся в ней инструкцию (исп-ся для переносимости)

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

Ввод/вывод в C

putchar(ch);	//  вывод символа
puts(str);	//  функция выводит строку символов на экран.
printf("x=%d", i);	// форматированный вывод
%d и %i - целое в 10-ной записи,  %o - 8-ричная,  %x - 16-ричная
%f, %e, %g (%E, %G)	// с плавающей точной
%c - символ,  %s  - строка, %p - адреса (или указатели).

char ch = getchar();		// получить символ
char *gets(char *string);	// нет контроля. не рекомендуется
scanf()	 - ввод в заданном формате. Например:
scanf("x=%d, y=%2d", &x, &y);	- не забывать ставить & !!!

//Обмен с массивом в памяти:
int sprintf( char *buffer, const char *format,... ); 
int sscanf( const char *buffer, const char *format,...);

//Преобразование числовых значений в символьное представление:
char *itoa( int  value, char *string, int radix );	 //	(radix - основание системы счисления)
char *ltoa( long value, char *string, int radix );
char *gcvt( double value, int ndec, char *str ); 	//	(ndec - кол-во значащих циф)

//Преобразование строк в числа:
int atoi( const char *string );
long atol( const char *string );
long  strtol( const char *string, char **endptr, int radix );
double strtod( const char *string, char **endptr );

Файлы

stdio.h - более высокий уровень, чем io.h, но более низкий, чем в С++.

В Си работа с файли реализована в форме потоков байт.

В начале выполнения программы среда исполнения С открывает 3 предопределенных потока:

stdin - стандартный входной поток,

stdout - стандартный выходной поток,

stderr - поток для сообщений об ошибках.

По способу организации обмена потоки бывают:

1) Небуферизованные (stderr);

2) Буферизованные:

- Строчно-буферизованные (stdin , stdout);

- Блочно-буферизованные (для обмена с дисковыми файлами).

По способу преобразования передаваемой информации:

- Бинарные;

- Текстовые.

FILE - структура для работы с файлом, определена в .

FILE *fopen(const char *filename, const char *mode); // открывает файл с именем filename и возвращает указатель на связанный с этим файлом  поток или  NULL при ошибке.
int fclose(  FILE  *fp  );  // закрывает указанный файл поток ( 0 = ok,  EOF - ошибка),  предварительно опустошив его буфер.
int fcloseall( void );	// закрывает все файлы (потоки), кроме предопределенных.

mode - способ доступа к файлу ("+" - двунаправленный поток):

r - открыть только для чтения;

w - открыть новый файл для записи (сущ-щий файл перезаписывается);

a - открыть для записи в конец файла или создать новый, если файл не существует;

r+ - открыть существующий файл для чтения и записи;

w+ - создать новый файл для чтения и записи (сущ-щий файл перезаписывается);

a+ - открыть (или создать, если не существует) для чтения/записи в конце файла.

Для указания типа потока к способу доступа добавляется символ t (текстовый) или b (бинарный), например, wt, a+b и т.д. По умолчанию задается значением глобальной переменной _fmode

Стандартные функции:

int fgetc(FILE *stream);	// ввод 1 символа
int fputc (int ch, FILE *stream); 
char *fgets(char *string, int n, FILE *stream); // ввод строки, n - макс. количество байт
int fputs(const char *string, FILE *stream);
int fscanf (FILE *stream, const char *format,...); 
int fprintf(FILE *stream, const char *format,...); 
size_t fread (void *ptr, size_t size, size_t n,  FILE *fp ); 
size_t fwrite(void *ptr, size_t size, size_t n,  FILE *fp );
int fseek( FILE *fp,  long offset,  int whence ) // возвращает  0 при нормальном завершении и ненулевое  - при ошибке.
    SEEK_SET ( ==0 )  - начало файла;
    SEEK_CUR ( ==1 )  - текущее положение;
    SEEK_END ( ==2 )  - конец файла.
int  ferror( FILE *fp ); // возвращает ненулевое значение, если в результате операции с файлом  fp устанавливается индикатор ошибки.
int  feof( FILE *fp );   // возвращает ненулевое значение, если при операции с файлом  fp установился индикатор конца файла.
int  fflush( FILE *fp );  /* опустошает буфер указанного потока (если поток входной, 
		то буфер чистится, если выходной  - его содержимое выводится в поток),  
		поток остается открытым; функция возвращает 0 приуспешном завершении и  EOF при ошибке. Или */
int flushall( void );

Некоторые другие полезные функции

int rand(void)	 // генерация случ. числа в диапазоне от 0 до RAND_MAX
void srand(unsigned seed); //  устанавливает начальное состояние генератора.
void exit(int status); //  завершает процесс выполнения  программы, 
int system(const char *command); //  вызывает командный процессор для исполнения 

Пример:

system("pause");

Для Windows полезные команды: pause, cls.

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

Литература:

http://ru.wikipedia.org/wiki/Ссылка_(C%2B%2B)