OpenSCADAWiki : Roman Savochenko / C Short All / part 1

1 Язык C/C++

/Roman Savochenko / C Short All / part 1 / part 1 :: (edit)

1.1 Ключевые слова С/С++

Таблица 1. Ключевые слова С/С++


Ключевые слова для С/С++
auto	break	case	char
const	continue	default	do
double	else	enum	extern
float	for	goto	if
int	long	register	return
short	signed	sizeof	static
struct	switch	typedef	union
unsigned	void	volatile	while
inline (C99)	restrict (C99)
Ключевые слова только для С++
asm	bool	catch	class
const_cast	delete	dynamic_cast	explicit
false	friend	virtual	mutable
namespace	new	operator	private
protected	public	reintepret_cast	static_cast
template	this	throw	true
try	typeid	typename	using
wchar_t

/Roman Savochenko / C Short All / part 1 / part 1 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 2 :: (edit)

1.2 Постоянные

Таблица 2. Постоянные языка С/С++


Целые константы
Десятичные	цифры 0-9;(12, 111, 956)
Восьмеричные	цифры 0-7;(012=10, 011=73, 076=62)
Шестнадцатеричные	цифры 0-9,буквы A-F или a-f(0x12=18, 0x2f=47, 0XA3=163)
Длинные целые константы
Десятичные	12l=12, 956L=956;
Восьмеричные	012l=10, 076L=62;
Шестнадцатеричные	0x12l=18, 0XA3L=163.
Беззнаковые целые константы
Десятичные	12u=12, 956U=956;
Восьмеричные	012u=10, 076U=62;
Шестнадцатеричные	0x12u=18, 0XA3U=163.
Константы с плавающей точкой
Всегда представляются типами float, double и long double: 345. = 345, 2.1e5 = 210000, .123E3fL = 123, 4037e-5l = .04037
Символьные константы
Состоит из одного символа кода ASCII, заключеного в апострофы: 'A', 'a', '7', '$'.
Многобайтовые символы: L'ab'.
Специальные символы:
\a	звонок
\b	возврат на один символ назад
\f	перевод страницы
\n	новая строка
\r	перевод каретки
\t	горизонтальная табуляция
\v	вертикальная табуляция
\'	апостроф
\"	двойные кавычки
\\	обратная дробная черта
\?	вопросительный знак
\x23	символ задан шестнадцатеричным числом
\023	символ задан восьмеричным числом
Строковые константы (литералы)
Представляет последовательность символов кода ASCII, заключённой в кавычки: "строка".

/Roman Savochenko / C Short All / part 1 / part 2 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 3 :: (edit)

1.3 Переменные

1.3.1 Основные типы переменных

Таблица 3. Основные типы переменных языка С/С++

Тип (байт_сист)	Диапазон значений	Граничные постоянные <limits.h>
bool (1)	false=0; true=1
char (1)	-128...127	CHAR_MIN...CHAR_MAX, CHAR_BIT
int (2_16)	-32.768...32.767	INT_MIN...INT_MAX
int (4_32)	-2³¹ ... 2³¹	INT_MIN...INT_MAX
short	-32.768...32.767	SHRT_MIN...SHRT_MAX
long (4_32)	-2³¹ ... 2³¹	LONG_MIN...LONG_MAX
long (8_64)	-2⁶³ ... 2⁶³	LONG_MIN...LONG_MAX
long long (8)	-2⁶³ ... 2⁶³	LLONG_MIN...LLONG_MAX
unsigned char (1)	0 ...255	0...UCHAR_MAX
unsigned (2_16)	0 ...65535	0...UINT_MAX
unsigned (4_32)	0 ... 2³²	0...UINT_MAX
unsigned short (2)	0 ...65535	0...USHRT_MAX
unsigned long (4_32)	0 ... 2³²	0...ULONG_MAX
unsigned long (8_64)	0 ... 2⁶⁴	0...ULONG_MAX
unsigned long long (8)	0 ... 2⁶⁴	0...ULLONG_MAX
enum (2_16)	32.768...32.767
enum (4_32)	-2³¹ ... 2³¹
float (4)	3.4*10³⁸ (7 знаков)
double (8)	3.4*10³⁰⁸ (15 знаков)
long double (12)	3.4*10⁴⁹³² (19 знаков)

1.3.2 Перечислимый тип (enum)

Определяет тип enum и/или enum переменную. Если фигурные скобки заданы то ключевое слово enum объявляет тип, состоящий из набора именованных целочисленных констант. Таким образом, enum переменная всегда имеет тип int. Enum может использоваться, для объявления констант, которые могут использовать имена без объявления переменных для них, как показано в следующем примере:


enum DAYS 
{
  saturday, 
  sunday = 10,
  monday, 
  tuesday,
  wednesday,
  thursday,
  friday
} today; 
enum DAYS yesterday = monday;
DAYS yesterday = monday;     // C++
int tomorrow = wednesday;

1.3.3 Структура (struct)

Объявляет тип структуры и/или переменную структуры. Если заданы фигурные скобки то определяется структурный тип. Безымянные разрядные поля могут использоваться для выравнивания.
Если фигурные скобки не заданы то ключевое слово struct используется для определения переменной структуры. В языке C++ добавлена возможность использования в структуре ключевых слов public, private, protect:


struct my_str;  //my_str - как прототип, определена позже 
struct POINT  
{
   int x;
   int y;
} here = { 20, 40 };
POINT here1 = (POINT){ 21, 41 };
struct POINT there, *ther1;
ther1->x = 2;           
struct CELL  { //Выбор количества битов для элементов
    unsigned character  : 8;   // 00000000 ????????
    unsigned foreground : 3;   // 00000??? 00000000
    unsigned intensity  : 1;   // 0000?000 00000000
    unsigned blink      : 1;   // 000?0000 00000000
    unsigned :1                // заполнитель
} screen[25][80]; 
POINT example(POINT there)    
{ 
  there.x = 3;
  there.y = 5;
};

1.3.4 Тип объединение (union)

Объявляет тип - объединение, и/или переменную объединения. Если фигурные скобки заданы то, union объявляет тип объединения, состоящий из последовательности переменных, значения (известных как элементы объединения) которых могут иметь различные типы. Переменная типа union может содержать один элемент любого типа, определенного объединением. Размером объединения является размер самого большого типа в объединении. Переменная может быть определена, указанием ее имени после заключительной фигурной скобки. Если фигурные скобки не даны, то ключевое слово union используется, для определения переменной объединения. Например:


union UNKNOWN  
{
  char   ch;       
  int    i;
  long   l;
  float  f;
  double d; 
} var1;               // Variable of type UNKNOWN
union UNKNOWN var2;   // Variable of type UNKNOWN
var1.i = 6;           // Use variable as integer
var2.d = 5.327;       // Use variable as double

C++ Поддерживает анонимные объединения: 
union 
{   
   int my_data;
   float this_data;  
};
my_data=3

1.3.5 Пустой тип (void)

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

1.3.6 Сокращенный тип (typedef)

Описание typedef используется для замены сложных типов данных или создания своих специфических типов данных:


typedef  unsigned long int ULINT;
ULINT    my_const;

1.3.7 Тип класс (class)

Общие понятия

В С++ добавлен класс - расширение понятия структуры. Память при определении класса не выделяется. Класс имеет имя и состоит из полей, представляющих его члены. В С++ допускается использование вложенных классов. Ключевое слово public определяет те члены класса, к которым имеется прямой доступ. Ключевое слово private используется для сокрытия определенных деталей класса, которые доступны только функциям членам класса и дружественным функциям. Все члены класса по умолчанию считаются приватными. Ключевое слово protected используется для открытия доступа только членам этого класса и членам производных от него классов. Функции класса могут определятся как внутри (увеличивается объем программы и скорость выполнения) так и вне (уменьшается объем программы и скорость выполнения) его тела. При создании в программе объекта экземпляра, его членам присваиваются некоторые начальные значения эту операцию выполняет специальная функция - конструктор, имя которой совпадает с именем класса. Для освобождения памяти и других операций при закрытии класса используется деструктор имя которого совпадает с именем класса и с добавлением впереди символа "~".

Для присваивания переменной одного класса переменной другого класса можно в классе использовать оператор: operator char *() в котором описывается процедура преобразования одной переменной в другую что позволит в дальнейшем упростить обмен: title=big_book.

Одинаковые классы допускают копирования содержимого из одного класса в другой.

Конструкторы с одним параметром определённого типа могут использоваться для неявного преобразования типов (от типа параметра к типу класса). Для исключения этого нужно использовать директиву explicit.


class book 
{
  public:
    char title[256];
    char author[64];
    book(char *title="A", char *autor="B", 
         char *publisher= "C") 
    {
       strcpy(book::title, title);
       strcpy(book::author, author);
       strcpy(book::publisher, publisher);  
    }; 
    ~book(void);          
    char *get_price(*publisher) {*publisher};
    char show_title(void); 
  private:
    char publisher[256];
};
book diary;
book::~book(void) 
{
  cout << "Уничтожение экземпляра" << title << '\n';  };
  void book::show_title(void) {cout << title << '\n'; };
  book tips("Jamsa's 1001 C/C++", "Jamsa", "Jamsa Press");
}

Дружественные классы и члены

Дружественные классы - friend указывает на класс (или функцию), который может использовать private члены текущего класса. Есть возможность узкого указания на член класса friend имеющего доступ к private членам текущего класса. Кроме того есть возможность создавать взаимные friend - классы. Дружественная функция может не принадлежать ни какому классу, т.е быть автономной.


class book 
{
  public:
    char title[256];
    char author[64];
    friend class Reader::show_reader(class book book);
  private:
    char publisher[256];
};
class Reader {
  public:
    Reader (char *name) {strcpy(Reader::name, name); };
    void show_reader(class book book) 
    {cout<<"Читатель"<<name<<' '<< "Издательство"<<book.publisher; }; 
    class book tips[23];
  private:
    char name[64];
};

Наследование

Наследование это когда производный класс наследует свойства родительского класса. Наследование обеспечивает возможность рассмотрения порождённого объекта как базового (но не наоборот). Наследование может быть множественным. В производном классе допускается переопределение функций базового. Для обращения к перегруженной функции базового класса можно записать d.TBase::getData();, где TBase - имя базового класса. Наследования бывают:

public -- Открытое наследование.
class circle: public point {};
При этом члены базового класса:
- public -- доступны любым нестатическим функциям-членам и функциям не являющимся членами;
- protected -- доступны любым нестатическим функциям-членам и дружественным функциям;
- private -- невидимы в производном классе;
private -- Закрытое наследование.
class circle: private point {};
При этом члены базового класса:
- public -- доступны любым нестатическим функциям-членам и дружественным функциям (делает public члены базового класса - private в производном);
- protected -- доступны любым нестатическим функциям-членам и дружественным функциям (делает protected члены базового класса - private в производном);
- private -- невидимы в производном классе;
protected -- Защищённое наследование.
class circle: protected point {};
При этом члены базового класса:
- public -- доступны любым нестатическим функциям-членам и дружественным функциям (делает public члены базового класса - protected в производном);
- protected -- доступны любым нестатическим функциям-членам и дружественным функциям;
- private -- невидимы в производном классе;
virtual -- используется для решения проблемы подобъектов-дубликатов (использование базового класса более раза).


class Cover 
{
  public:
     static int count;
     Cover(char *title) { strcpy(Cover::title, title) ;};
  protected:
     char title[256];
};  
class book 
{
  public: 
     book (char *title) {srcpy(book::title, title); };
     void show_title(void) {cout << title <<endl; };
  protected:
     float cost;
     void show_cost(void) {cout<<cost<<endl; };   
  private:
     char title[64];
};
class LibraryCard : public Cover, public book {
  public:
     LibraryCard(char *title, char *author, char *publisher):
     book(title)  
     {
        strcpy(LibraryCard::author, author);
        strcpy(LibraryCard::publisher, publisher);
        cost = 39.95; 
     };
  private:
     char author[64];
     char publisher[64];
};

Полиморфизм

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


class Base
{
  public: 
    void base_mess(void) {cout<<"Base\n"; }; 
    virtual void show_mess(void) { cout<<"Base";};  
    virtual void show_reserve(void) = 0;   
};
class Der: public Base
{
  public: 
    void der_mess(void){       }; 
    virtual void show_mess(void) { cout<<"Der";};         
    virtual void show_reserve(void){ cout<<"           ";};  
};
void main(void) 
{ 
  Base *base_pointer = new Base;
  base_pointer->base_mess();
  base_pointer->show_mess();
  base_pointer = new Der;
  base_pointer->der_mess();
  base_pointer->show_mess();   
}

Инициализаторы

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


class Time
{
  public: 
    Time();   
    const int time;
};
Time::Time() : time(10)
{...};

Композиция

Классы допускают композицию т.е включение одного объекта в другой. Включенные объекты уничтожаются после уничтожения содержащего их объекта.


class Time
{
  public: 
    Time();   
    const int time;
};
class Date
{
  public
    Date();
  private
    const Time time;
}
Date::Date : time()
{...};

Ссылка на себя

В классах есть возможность ссылаться на себя. Эта функция обеспечивается ключевым словом <this> которое содержит адрес текущего объекта. Может использоваться сцепления путём возврата адреса или ссылки объекта его членами функциями.

Proxy классы

Proxy классами называются классы которые призваны скрывать private члены классов закрытой реализации библиотеки. Создаются они путем создания указателя на скрываемый класс в private поле proxy класса:


class Sequry
{
  public
    void setValue(int x);
  private: 
    int value;   
};
class Proxy
{
  public
    setValue(int x) {ptr->setValue(x);};
  private
    Sequry *ptr;
}

/Roman Savochenko / C Short All / part 1 / part 3 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 4 :: (edit)

1.4 Синтаксис

1.4.1 Полезные обороты

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


long с = (long)a; - традиционная запись; 
long с = long(a); - функциональная запись;

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


int x,  // x
    y,  // y
    z;  // z

Варианты использования параметров функций:
- для меняющихся аргументов необходимо использовать ссылки или указатели (ссылки на массив);
int test(int *ptr, int &alias, int[] &mass );
- для неизменяемых аргументов использовать прямую передачу по значению ;
int test(int value);
- для больших неизменяемых аргументов использовать константные ссылки или указатели на константные данные;
int test(const int &value, const int *ptr);

Использование ключевого слова const (запрет модификации):
- неконстантный указатель на неконстантные данные;
void test(char *str);
- неконстантный указатель на константные данные;
void test(const char *str);
- константный указатель на неконстантные данные;
int * const ptr = &x;
- константный указатель на константные данные;
const int * const ptr = &x;
- константный класс – не позволяет запускать неконстантные функции члены, кроме конструктора и деструктора;
const Time moon(12,0,0);
- константная функция – недопускется ничего (кроме mutable членов) модифицировать в константных функциях, а также вызывать неконстантные функции;
int getValue() const;

Предотвращение многократного включения заголовочных файлов:


#ifndef TEST_H
#define TEST_H

<code>

#endif

Комментирование/исключение больших кусков кода:


#if 0
<code>
#endif

Использование значений параметров функций по умолчанию:


void show_values(int one=1, int two=2, int three=3);
show_value();
show_value(23);

Объявление переменных по месту:


for (int count = 0; count < 10;count++)

Функции переменного числа параметров:


void text(parm x,char *fmt, ...)
 {
   char str[100];   

   va_start (argptr,fmt);
   vsprintf(str,fmt,argptr);
   va_end(argptr);
   printf(str);
 }

 text(54,"hello %s","world");

Указание способа(языка) для которого должна компилироваться функция:


extern "C" func();  // В стиле "C"
 extern "C++" func(): // В стиле "C++"
 extern "C++" 
 {
  int func(void);
 }

1.4.2 Указатели

Особенностью языка С/С++ является возможность доступа к переменной не только по имени но и с использованием механизма указателей. Для этого в языке предусмотрены символы: “&" и "*".

Символ "*" используется для индикации переменной (*ptr), которая расположена в памяти по адресу на который указывает одноимённая переменная без звёздочки. Символ “&" используется как для определения адреса ячейки памяти переменной, так и для определения адреса указателя на переменную.

Назначение адреса указателя:


int *ptr = (int *)0x0010;   //при инициализации  
 ptr      = (int *)0x0010;   //в программе

Присвоение значения непосредственно переменной на которую указывает указатель:


*ptr = 300

Родовой указатель в С/С++ основан на использовании указателя типа (void *). Ключевое слово void говорит об отсутствии данных о размере объекта в памяти. Во всех случаях использования указателя описанного как void*, необходимо выполнять операцию явного приведения типа указателя:


unsigned long block = 0xffeeddccL; 
 void *ptr = &block;
 unsigned char = *(unsigned char *)ptr; 
 long int four_bytes = *(long int *)ptr;

Определение адреса указателя:


int *ptr; 
 k = &ptr;

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


int data = 5;
 int *ptr = &data;    // ptr[0]==5; 
 int **ptr1 = &ptr;   // ptr1[0][0]==5; 
 int ***ptr2 = &ptr1; // ptr2[0][0][0]==5;

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


bool *cimpare(int, int);

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


bool (* compare)(int, int);

Указатели на члены класса (.* и ->*)


class Test
{
  public:
    void funct() { cout << "Функция\n"; }
    int value;
};

Test t;
Test *tPtr = &t;
void (Test::*memPtr)() = &Test::funct;
int  Test::*vPtr = &Test::value;
(tPtr->*memPtr)(); //косвенный вызов функции
cout << (*tPtr).*vPtr << endl;

1.4.3 Ссылки (C++)

Ссылка являются псевдонимом (алиасом) от переменной на которую она ссылается. При изменении ссылаемой переменной изменяется ссылка. В основном ссылки используются при описании параметров функций и указывают что переменная может меняться.


int &test(int &x);
 int data = 5;
 int &al_data = data;    // al_data == 5; 
 al_data = 10;           // data == 10; 
 data = 7;               // al_data == 7;

1.4.4 Массивы

Как и в других языках, С/С++ поддерживает массивы которые тесно переплетаются с указателями. Элементы массива имеют один и тот же тип и расположены в памяти друг за другом. Имя массива также можно воспринимать как указатель на начало массива.

В отличие от других языков в С/С++ отсутствует специальный строковый тип. Вместо него строковые литералы представляются как одномерный массив элементов типа char оканчивающегося символом “0”.

Явное указание числа элементов массива и списка начальных значений:


char array[]  = {'A','B','C','D',0};
 char array[]  = "ABCD";
 char array[5] = {'A','B','C','D',0};
 char *string  = "ABCD";
 string        = "ABCD";

Обращение к элементам массива с помощью указателя:


*(array+i); 
 array[i][j];    
 *(array[i]+j);  
 *(*(array+i)+j);

Многомерные массивы:


matrix[2] == &matrix[2][10]; 
 long (* matrix1)[3][2][4];
 matrix1 = new long[3][2][4];
 char *messages[20] == char messages[20][80]);
 char string[][80]=
 {
   "Первая строка",
   "Вторая строка",
   "Следующая строка"
 }; 
 int m[][3] = { {00}, {10, 11}, {20, 21, 22,} }; 
 char *Names[]= { "Aleksey", "Vladislav", "Vitaly" };

Массив указателей на функцию:


int  (* fcmp[5])(int) =  
 {cmp_name, cmp_title, cmp_year, cmp_price, cmp_totaly};
 void (* func[3])(int);    //определение
 (* func[choice])(choice); //вызов

1.4.5 Перегрузка функций

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


int sum(int *array, int element) {   }
 float sum(float *array, int element) {   }

1.4.6 Перегрузка операций

Перегрузкой операция является процедура расширения функций существующих операция для новых типов x(объектов). Операции допускающие перегрузку указанны в табл.4. При перегрузке операций их старшинство и ассоциативность не изменяется.

Унарная операция (префиксная).

Операция:! S
Вызывает: S.operator!() или operator!(S)
Объявляется: bool operator!() const; или friend bool operator!(const String &);

Унарная операция (постфиксная).

Операция: d1++
Вызывает: d1.operator(0) или operator(d1,0)
Объявляется: Date::operator(int); или friend Date::operator(Date &,int);

Бинарная операция.

Операция: y+=z
Вызывает: y.operator+=(z) или operator+=(y,z)
Объявляется: const String &operator+=(const String &); или friend const String &operator+=(String &, const String &);

Вызов функции.

Операция: string(2,2);
Вызывает: string.operator()(2,2);
Объявляется: String operator()(int,int);

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

Операция: (char *)S;
Вызывает: S.operator char*()
Объявляется: String operator char*(); или String(char *); (конструктор неявного преобразования).

операция “new”.

Операция: Class1 *cls = new Class1; или Class1 *cls = new («class») Class1;
Вызывает: Class1 *cls = Class2.operator new(sizeof(Class1)); или Class1 *cls = Class2.operator new(«class», sizeof(Class1));
Объявляется: void* Class2::operator new(size_t size); или void* Class2::operator new(string modul, size_t size);

операция “delete”.

Операция: delete cls;
Вызывает: Class2.operator delete(cls);
Объявляется: void* Class2::operator delete(void *addr);

Таблица 4. Операции допускающие перегрузку

+	-	*	/	%	^	&	\|
~	!	=	<	>	+=	-=	*=
/=	%=	^=	&=	\|=	<<	>>	>>=
<<=	==	!=	<=	>=	&&	\|\|	++
--	->*	,	->	[]	()	new	delete
new[]	delete[]

1.4.7 Шаблоны

Шаблоны определяются с помощью ключевого слова template и предназначены для определения функций и классов способных работать с различными типами входных и выходных параметров. Шаблоны и наследование связаны следующим образом:

шаблон класса может быть производным от шаблонного класса;
шаблон класса может являться производным от нешаблонного класса;
шаблон класса может быть производным от шаблона класса;
нешаблонный класс может быть производным от шаблона класса.

Шаблонные классы:

Объявление:


template <class Templ>
 class Tree 
 {
   public:
     Tree( const Templ& n );
     insertN(const Templ &);
 } 
 template <class Templ>
 Tree<Templ>::Tree(const Templ& n) { };

Использование:


Tree<int> NewTree(23); 
 Tree<float> NewTree(56.8);

Шаблонные функции:

Объявление:


template <class T> // или template <typname T>;
 T max(T val1, T val2, T val3)
 {
   T max = val1;
   if(val2 > max) max=val2; 
   if(val3 > max) max=val3; 
   return max;
 }

Использование:


int rez = max(1,10,3);
 float rez = max(0.5,9.99,6.78);

Шаблоны и друзья:


friend void f1();    //друг любого класса
 friend void f2(x<T> &); //друг конкретного класса
 friend void A::f4(); //друг любого класса
 friend void C<T>::f5(x<T> &); //друг конкретного класса
 friend class Y;      //класс Y дружественен любому классу
 friend class Z<T>;   //класс Y дружественен конкретному классу

1.4.8 Обработка исключительных ситуаций

В языке C++, добавлен мощный аппарат обработки исключительных ситуаций. Этот аппарат позволяет отлавливать как все типы исключений, так и конкретно взятый тип исключений. Так если записать catch(...), то будут отлавливаться все типы исключений. Кроме того обработка исключительных ситуаций оказываться вынесенной из «основной линии» выполнения программы. Для генерации повторных исключений в catch опускаться использование (throw) без параметров. Если происходит глубоковложенное исключение, то выполняется «раскрутка» стека для возвращения до ближайшего catch Обработка исключительных ситуаций описывается следующим образом:


try  //начало блока испытания
{
  if() throw MyType();    // Принудительная генерация 
}                         //  (точка генерации)
catch(MyType &Mt) {...}; // Отлов и обработка исключений My Type
catch(...){...}; // Отлов и обработка всех остальных исключений

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


int g(double h) throw(a,b,c) //может генер. a,b,c и 
                              //unexpected
 int g(double h) throw()      //не может генерировать
                              //(кроме unexpected)
 int g(double h)              //может генерировать все

Стандартные обработчики исключений:

bad_alloc (exception) — ошибка выделения памяти с помощью new;
bad_cast (exception) — генерируется dynamic_cast;
bad_exception (exception) — неожиданное исключение генерируется в случае неожиданного исключения при включении std::bad_exception в throw-список функции;
bad_typeid (exception) — генерируется typeid;
invalid_argument (exception) — функции передан недопустимый аргумент;
logic_error (exception) — исключения в логических операциях;
length_error (exception) — длина более максимально допустимой;
out_of_range (exception) — аргумент вне допустимого диапазона;
runtime_error (exception) — Ошибка в программе;
overflow_error (runtime_error) — математическая ошибка переполнения сверху;
underflow_error (runtime_error) — математическая ошибка переполнения снизу;

Чтоб избежать утечек памяти, обусловленных забыванием вызова delete после new, можно использовать шаблон auto_ptr, который будет автоматически разрушаться.

На базе класса exception, можно генерировать собственные исключения.

/Roman Savochenko / C Short All / part 1 / part 4 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 5 :: (edit)

1.5 Операции

Таблица 5. Операции языка С/С++

Символ	Описание	Направл.
Самый высокий приоритет
::(унарн)	Область видимости	справа
::(бинар)	Область видимости	слева
()	Вызов функции	слева
[]	Выделение элемента массива	слева
->	Выделение элемента структуры адресуемой указателем	слева
.	Выделение элемента структуры или объединения	слева
->*	Обращение по адресу объекта к адресу функции объекта	слева
.*	Обращение через объект к адресу функции объекта	слева
++	Пост-приращение	справа
--	Пост-декремент	справа
+	Унарный плюс	справа
-	Унарный минус	справа
!	Логическое отрицание	справа
~	Побитовое отрицание	справа
(тип)	Приведение типов: (float)i	справа
*	Обращение по адресу переменной	справа
&	Определение адреса переменной	справа
sizeof	Определение размера, в байтах	справа
*	Умножение	слева
/	Деление	слева
%	Остаток от деления	слева
+	Сумма	слева
-	Разность	слева
<<	Сдвиг влево	слева
>>	Сдвиг вправо	слева
<	Меньше	слева
<=	Меньше и равно	слева
>	Больше	слева
>=	Больше и равно	слева
==	Равно	слева
!=	Неравно	слева
&	Поразрядный «И»	слева
^	Поразрядный «исключающий ИЛИ»	слева
\|	Поразрядный «ИЛИ»	слева
&&	Логический «И»	слева
\|\|	Логический «ИЛИ»	слева
?:	Условная операция(int i=(val>=0)?val:-val;)	справа
=	Присваивание	справа
+=, -=, *=, /=, %=, \|=, &=, <=, >=	Составное присваивание	справа
,	Операция последования (последовательность выполнения)	слева

/Roman Savochenko / C Short All / part 1 / part 5 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 6 :: (edit)

1.6 Операторы

1.6.1 C

break
Прекращает выполнение ближайшего внешнего оператора: do, for, switch или while.


for(;;) { printf("TEST"); break; }

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


switch(i)
{
  case 1: printf "Val 1"; break;
  case 2: printf "Val 2"; break;
  default: printf "Other";
}

continue
Передает управление в начало оператора цикла do, for, или while вызывая следующую итерацию.


for(i=0;i<2;i++){printf("test"); continue; exit(1);}

default
Используется в switch для выполнения действий неудовлетворяющим ни одному условию.

do
do оператор while(выражение);
Выполняет <оператор>, пока <выражение> истинно. Условие проверяется в конце цикла.

else
if (выражение) выражение1; [else выражение2;]
Выполняет <выражение2> если <выражение> не истинно.

for
for(init-expr; cond-expr; increment) оператор;
Выполняет <оператор>, пока инициализированное число <init-expr>, над которым производится операция <increment>, удовлетворяет условному выражению <cond-expr>.

goto
Оператор безусловного перехода. Управления передается на оператор с меткой <имя:>.

if
if (выражение) выражение1; [else выражение2;]
Выполняет <выражение1>, если <выражение> истинно (отлично от нуля). Если else присутствует, и <выражение> – ложно (нуль), выполняется <выражение2>. После выполнения <выражение1> или <выражение2 >, управление переходит к следующему оператору.

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

switch
Сравнивает <выражение> с константами во всех вариантах case и выполняет оператор связанный с <постоянной-выражением>. Если отсутствует соответствия с постоянных с выражениями то выполняется утверждение, связанное с ключевым словом default. Если ключевое слово default не используется то управление переходит к утверждению после блока переключателя.


switch(выражение){ 
 case константа1: выражение1; [break;] 
 case константа(n): выражение(n); [break;] 
 [default: выражение(n+1);] 
}

while
while(выражение) оператор;
Выполняет <оператор>, пока <выражение> истинно.

1.6.2 C++

explicit
Ставится перед конструктором объекта и предотвращает использование конструктора для неявного преобразования типов.

namespace
Назначение области действия имён:


namespace Example { int myvar; } 
 k = Example::myvar;

this
Содержит указатель на собственный объект класса (т.е на себя);

typeid
Возвращает ссылку на объект type_info. Объект type_info – это поддерживаемый системой объект, представляющий тип.


const char *dataType = typeid(T).name();

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

using
Делает глубоковложенную команду, со специальной областью видимости, видимой по умолчанию:


using std::cout; 
 cout << "test"; 
 using namespace math;

Операторы преобразования типов

static_cast
Выполняет стандартные преобразования (статическое):


int x = static_cast<int>(d); 
 string s = static_cast<string>("ch_string"); 
 derivedPtr = static_cast<DerivedClass *>(basePtr); (преобразование потомка к базовому классу)

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


cylinderPtr = dynamic_cast<const Cylinder *>(shapePtr); 
 if(cylinderPtr != NULL) shapePtr->area(); //Цилиндр

const_cast
Используется для снятия константности или volatile путём приведения:


const_cast<const CastTest *>(this)->number-; (при вызове из константной функции)

reinterpret_cast
Для нестандартных преобразований:


count << *reintepret_cast<char *>(ptr) « endl; (преобразует (int *) в (char *) и разыменовывает)

Ключевые слова-операторы

Стандарт языка C++ предоставляет ключевые слова-операторы, которые могут использоваться вместо нескольких операторов C++ (таблица 6).

Таблица 6. Ключевые слова-операторы языка С++

Оператор	Слово-оператор	Описание
Логические операторы-ключевые слова
&&	and	логическое И (AND)
\|\|	or	логическое ИЛИ (OR)
!	not	логическое НЕ (NOT)
Оператор «не равно»-ключевое слово
!=	not_eq	не равно
Побитовые операторы-ключевые слова
&	bitand	побитовое И (AND)
\|	bitor	побитовое включающее ИЛИ (OR)
^	xor	побитовое исключающее ИЛИ (OR)
~	compl	побитовое инвертирование разрядов
Побитовые операторы присваивания-ключевые слова
&=	and_eq	побитовое И (AND) и присваивание
\|=	or_eq	побитовое включающее ИЛИ (OR) и присваивание
^=	xor_eq	побитовое исключающее ИЛИ (OR) и присваивание

/Roman Savochenko / C Short All / part 1 / part 6 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 7 :: (edit)

1.7 Спецификаторы класса памяти

auto
Указывающий на то, что переменная имеет локальную (автоматическую) протяженность. Разрушается при выходе из функции.

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

extern
Определяет переменную которая должна быть видна в других объектных модулях.

mutable
Определяет в классе переменную которую можно модифицировать даже из константной функции.

static
Объявляет переменную которая будет являться одной для всех экземпляров функции и которая инициализируется при запуске программы. Статические функции объектов определяются в одном экземпляре и становятся видимыми за пределы класса владельца. Кроме того статическая функция член не может являться константной и имеют доступ только к статическим полям. Static в глобальном отношении может использоваться для ограничения области действия переменной пределами одного файла.


static int getCount();

/Roman Savochenko / C Short All / part 1 / part 7 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 8 :: (edit)

1.8 Препроцессор

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

Определение/удаление макроса. Макрос может быть определён без значения и может использоваться в качестве проверяемого флага.


#define VAL_T 345
 #undef VAL_T
 #define VAL_T 234

Для перевода на другую строку используется ";\" :


#define FILLSCREAN(color) _AX = 0x0600;\
                           _CX = 0x0000;\
                           _DX = 0x184f;\
                           _BH = color;\
                           geninterrupt(0x10);

Использование параметров:


#define min(a,b) ((a) < (b) ? (a) : (b))
 result = min(44,uplimit);   
 // result = ((44) < (uplimit) ? (44) : (uplimit));

Для объединения формальных параметров используются символы ##:


#define var( i , j ) ( i##j )   // var( x , 6 ) = x6

Для преобразования фактического параметра в строку используется символ # который помещается перед формальным макропараметром:


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

Вариантный макрос (...):


#define err(...) fprintf(stderr,__VA_ARGS__)
 err("%s %d\n","The error code ",48); 
 // fprintf(stderr,"%s %d\n","The error code ",48);

 #define errout(a,b,...) \
     fprintf(stderr,"File %s  Line %d\n",a,b); \
     fprintf(stderr,__VA_ARGS__)
 errout(__FILE__,__LINE__,"Unexpected termination\n");

1.8.1 Директивы Препроцессора

_Pragma
_Pragma(«GCC poison printf»)
Оператор для вызова прагмы из тела макроса (табл.7).

#define
#define ident ident1;
Заменяет все последующие определения <ident> на лексему <ident1> (совокупность лексем).

#elif, #if
#if expresion
#elif expresion1
#endif
Проверяет выражение <expresion>, связанное с директивами #if, или #elif, если выражение истинно (отличный от нуля), то выполняются следующие строки до директив условия или конца условий. Директива #elif является объединением директив #else и #if. Если имеется #else, то нижестоящие строки выполняются когда выражение в #if или #elif имеет нулевое значение. Нельзя использовать в качестве условия оператор sizeof, составные типы, float или enum типы.

defined
#if defined(VAR)
#elif !defined(NVAR)
#endif
Оператор проверки определённости, используется в паре с #if.

#else
Нижестоящие строки выполняются если выражение в #if, #ifdef, #ifndef или #elif имеет нулевое значение.

#endif
Указывает на конец условия.

#error
#error сообщение
Генерация сообщения ошибки на stderr и завершения процесса компиляции.

#ifdef
#ifdef <identifier>
Выполняет последующие строки до #endif, если <identifier> был ранее определен.

#ifndef
#ifndef <identifier>
Выполняет последующие строки до #endif, если <identifier> не был ранее определён.

#include
#include <filename>
Вставляет содержимое файла <filename> в текущий файл. Если путь к имени файла включен в двойные кавычки, то поиск осуществляется внутри текущего каталога.

#include_next
#include_next <filename>
?

#line
#line n file
Изменяет внутренний номер строки компилятора на <n>, а также изменяет внутреннее имя файла на <file>. Текущий номер строки и имя файла доступны через константы препроцессора __LINE__ и __FILE__.

#pragma
#pragma directives
Инструктирует компилятор, о выполнение машинно-специфических возможностей, определенных параметром <directives> (таблица [*]).

#undef
#undef identifier
Удаляет текущее определение <identifier>, который был предварительно определен директивой #define.

#warning
#warning сообщение
Генерация сообщения предупреждения на stderr и продолжение компиляции.

Таблица 7. Параметры директивы pragma, препроцессора

Имя	Назначение
pack	Определяет, как компилятор выравнивает данные при сохранении в памяти. Может также использоваться с, вталкиванием и выталкиванием параметров. `#pragma pack(n) #pragma pack(push, n) #pragma pack(pop)`

Таблица 8. Предопределённые символьные константы

Имя	Назначение
__BASE_FILE__	Полный путь к каталогу исходного файла.
__CHAR_UNSIGNED__	Указывает на то, что символьный тип является безнаковым.
__cplusplus	Указывает на то, что исходный код является программой на языке С++.
__DATE__	Дата компиляции исходного файла (строка).
__FILE__	Имя исходного файла (строка).
__func__	Имя текущей функции.
__FUNCTION__	Имя текущей функции.
__PRETTY_FUNCTION__	Полное имя текущей функции. Для C++ включает имена классов.
__INCLUDE_LEVEL__	Глубина включения (include) файла.
__LINE_	Номер текущей строки исходного текста (целое число).
__NO_INLINE__	Указывает на отсутствие inline-функций.
__OBJC__	Программа на языке Objective-C.
__OPTIMIZE__	Указывает на то, что назначен уровень оптимизации.
__OPTIMIZE_SIZE__	Оптимизация размера программы.
__STDC__	Компилятор соответствует правилам стандарта языка C.
__TIME__	Время компиляции исходного файла (строка).
__VERSION__	Полный номер версии.

/Roman Savochenko / C Short All / part 1 / part 8 :: (edit)

/Roman Savochenko / C Short All / part 1 / part 9 :: (edit)

1.9 Стандартные заголовочные файлы

assert.h | cassert (ANSI)
Содержит макросы и информацию, для дополнительной диагностики, помогающей при отладке программы.

bios.h (DOS)
BIOS сервисные функции (INT 10).

conio.h (DOS)
Подпрограммы Ввода – вывода.

ctype.h | cctype (ANSI)
Символьная классификация.

dirent.h (ANSI)
Управление каталогами.

dos.h (DOS)
MS-DOS функции (INT 21).

env.h (POSIX)
Содержит прототипы для окружений строковых функций.

errno.h | cerrno (ANSI)
Переменные, и утилиты обработки ошибок.

fcntl.h (POSIX)
Флажки, используемые в функциях open и sopen.

float.h | cfloat (ANSI)
Содержит предельные размеры переменных с плавающей точкой для данной системы.

graph.h (DOS)
Программы для работы с графикой низкого уровня.

io.h (DOS)
Низкоуровневый ввод-вывод.

limits.h | climits (ANSI)
Содержит общие ограничения системы.

locale.h (ANSI)
Содержит информацию для выполнения локализации ПО.

malloc.h (ANSI)
Содержит прототипы функций распределения памяти.

math.h | cmath (ANSI)
Содержит прототипы математических библиотечных функций.

memory.h
Подпрограммы манипуляции с буферами.

serach.h
Функции поиска и сортировки.

setjmp.h (ANSI)
Прототипы Функций setjmp и longjmp (безусловного перехода)

signal.h (ANSI)
Прототипы функций для работы с сигналами и описание самих сигналов.

stdarg.h (ANSI)
Содержит макрокоманды для работы с функциями имеющими список параметров переменной длины.

stdio.h | cstdio (ANSI)
Содержит прототипы стандартных библиотечных функций ввода-вывода и используемую ими информацию.

stdlib.h | cstdlib (ANSI)
Содержит прототипы функций для преобразования чисел в текст, текста в числа, для выделения памяти, генерации случайных чисел и других полезных операций.

string.h | cstring (ANSI)
Содержит прототипы функций для обработки строк стиля C.

strstream.h | strstream (ANSI)
Для формирования строк через поток.

time.h | ctime (ANSI)
Содержит прототипы функций для работы со временем и датами.

unistd.h (POSIX)
Символьные константы POSIX.

iostream
Содержит прототипы функций стандартного ввода и вывода.

iomanip
Содержит прототипы функций для операций с потоками, дающие возможность форматировать потоки данных.

fstream
Содержит прототипы функций для операций с файловым вводом-выводом.

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

vector, list, deque, queue, stack, map, set, bitset (STL)
Содержат классы которые реализуют контейнеры стандартной библиотеки.

functional
Содержит классы и функции, используемые алгоритмами стандартной библиотеки.

memory
Содержит классы и функции, используемые стандартной библиотекой для выделения памяти контейнерам стандартной библиотеки.

iterator
Содержит классы для доступа к данным в контейнерах стандартной библиотеки.

algorithm
Содержит функции для манипулирования данными в контейнерах стандартной библиотеки.

exception, stdexcept
Содержат классы использующиеся для обработки исключительных ситуаций.

string
Определения класса string из стандартной библиотеки.

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

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

limits
Содержит классы для определения интервалов значений численного типа данных для данной платформы.

typeinfo
Содержит классы для идентификации времени выполнения.