Вход:  Пароль:  
Free Source | Каталог | Изменения | НовыеКомментарии | Пользователи | Регистрация |

1 Язык C/C++

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


Таблица 1. Ключевые слова С/С++
Ключевые слова для С/С++
autobreakcasechar
constcontinuedefaultdo
doubleelseenumextern
floatforgotoif
intlongregisterreturn
shortsignedsizeofstatic
structswitchtypedefunion
unsignedvoidvolatilewhile
inline (C99)restrict (C99)
Ключевые слова только для С++
asmboolcatchclass
const_castdeletedynamic_castexplicit
falsefriendvirtualmutable
namespacenewoperatorprivate
protectedpublicreintepret_caststatic_cast
templatethisthrowtrue
trytypeidtypenameusing
wchar_t

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'a', L'b'
Специальные символы:
\aзвонок
\bвозврат на один символ назад
\fперевод страницы
\nновая строка
\rперевод каретки
\tгоризонтальная табуляция
\vвертикальная табуляция
\'апостроф
\"двойные кавычки
\\обратная дробная черта
\?вопросительный знак
\23символ задан десятичным числом
\0x23символ задан шестнадцатеричным числом
\023символ задан восьмеричным числом
Строковые константы (литералы)
Представляет последовательность символов кода ASCII, заключённой в кавычки: «строка».

1.3 Переменные

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


Таблица 3. Основные типы переменных языка С/С++
Тип (байт_сист)
Диапазон значений
Граничные постоянные <limits.h>
bool (1)false=0, true=1
char (1)-128...127CHAR_MIN...CHAR_MAX, CHAR_BIT
int (2_16)-32.768...32.767INT_MIN...INT_MAX
int (4_32)-231 ...231INT_MIN...INT_MAX
short -32.768...32.767SHRT_MIN...SHRT_MAX
long (4_32)-231 ...231 LONG_MIN...LONG_MAX
long (8_64)-263 ...263 LONG_MIN...LONG_MAX
long long (8)-263 ...263LLONG_MIN...LLONG_MAX
unsigned char (1)0 ...2550...UCHAR_MAX
unsigned (2_16)0 ...655350...UINT_MAX
unsigned (4_32)0 ...2320...UINT_MAX
unsigned short (2)0 ...655350...USHRT_MAX
unsigned long (4_32)0 ...2320...ULONG_MAX
unsigned long (8_64)0 ...2640...ULONG_MAX
unsigned long long (8)0 ...2640...ULLONG_MAX
enum (2_16)32.768...32.767
enum (4_32)-231 ...231
float (4)3.4*1038 (7 знаков)
double (8)3.4*10308 (15 знаков)
long double (12)3.4*104932 (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 };    
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") 
    {
       strncpy(book::title, title, 256);
       strncpy(book::author, author, 64);
       strncpy(book::publisher, publisher, 256);  
    }; 
    ~book();          
    char *get_price(char *publisher) {return *publisher;}
    void show_title();

  private:
    char publisher[256];
};

book diary;

book::~book() {
cout << "Уничтожение экземпляра" << title << '\n';
}

void book::show_title() {
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 – имя базового класса. Наследования бывают:


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;
}


1.4 Синтаксис

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

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

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



#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

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 *); (конструктор неявного преобразования).
Операция: 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 cls;
Вызывает: Class2.operator delete(cls);
Объявляется: void* Class2::operator delete(void *addr);

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

+-*/%^&|
~!=<>+=-=*=
/=%=^=&=|=<<>>>>=
<<===!=<=>=&&||++
--->*,->[]()newdelete
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)              //может генерировать все


Стандартные исключения:


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


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


1.5 Операции


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

1.6 Операторы

1.6.1 C

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

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


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

switch(i)
{
  case 
1printf "Val 1"; break;
  case 
2printf "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; } 
 
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 != NULLshapePtr->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) и присваивание

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

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


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


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


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


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

static int getCount();


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__Полный номер версии.

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
Содержит классы для идентификации времени выполнения.


 
Файлов нет. [Показать файлы/форму]
Комментариев нет. [Показать комментарии/форму]