Постоянная ссылка

Шаблоны в C++ для начинающих очень часто непонятны и представляют темный лес. В некоторых книгах описано очень мудрено, где-то описано попроще. Попытаемся понять что такое шаблоны функций.

Для хорошего усвоения материала необходимо хорошо ориентироваться и знать параметры функций, прототипы функций.

=============

 template <class T>  //Шаблон функции с одним параметром T
 
  T MyFunc(T a)  //Тип функции MyFunc определяется шаблоном. В функцию принимается один параметр a, тип которого также определяется шаблоном
{
 return a; //Что приняли, то и вернули
}

void main()
{
 system("CLS");
  cout<<MyFunc(10)<<endl; //MyFunc возвращает тип int 
  cout<<MyFunc(10.222)<<endl; //MyFunc возвращает тип double
  cout<<MyFunc("HELLO")<<endl; //возвращает тип массив char
 system("PAUSE");
}
=============
 Ключевое слово template обозначает Шаблон.
  template <class T> обозначает Шаблон функции с одним параметром T 
 Несложно заметить большое сходство с написанием прототипа обычной функции. 


После Написания template и указания в угловых скобках всех параметров (В приведенном примере один параметр T) в примере написана функция MyFunc. Вместо явного указания типа, тип для функции и тип для параметра этой функции был указан как тип по Шаблону.  Для такого указания типа используются имена параметров, указанных в угловых скобках Шаблона.
 Проще говоря - этот описанный T можно изменить на привычный вам тип (int, double или другой)


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


Дальше проще.  Функция MyFunc возвращает некоторое значение. Для того, чтоб было максимально просто понять материал,- что функция принимает, то и возвращает, используется только один параметр. Так как функция возвращает один параметр, то и в шаблоне для этой функции должен быть указан один параметр. (как я писал ранее - очень похоже на прототипы функций). Если в шаблоне указан один параметр - то и внутри функции по этому шаблону нужен один, если два - то два и т.д.

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

Увы, лучше я написать не могу. И код понять намного проще чем читать подробное описание.


 Небольшой, стандартный пример на сравнение двух чисел и вывод большего из них 
Код C++ Шаблоны функций Сравнить два числа и вернуть большее значение
===============

template <class T>
 T max(T a, T b)
  {
   if (a>b) return a;
   else return b;
  }
 
void main()
{
 system("CLS");
  cout<<max(12,100)<<endl; 
  cout<<max(12.33,3.0)<<endl;
  //cout<<max(12.33,3)<<endl;  - ОШИБКА
 system("PAUSE");
}
===============
 Небольшой код, в функцию max передается два параметра, тип которых при приеме внутри функции определяется шаблоном. В самом шаблоне определяемый тип указан как один параметр. В коде указан момент, который может привести к ошибке. Просто если в самом Шаблоне указан один параметр, то такая запись интерпретируется компилятором как "Сколько бы функция не принимала параметров вовнутрь себя, возложив на меня обязанности указания типов, все эти параметры я расценю как однотипные" и, соответственно работайте с ними как с однотипными и не выпендривайтесь.

 На любом экзамене подобный ответ скорее всего двойка, но зато хорошо помогает понять некоторые принципы.

Если нужно, чтоб Шаблон обрабатывал параметры как параметры с разными типами, значит нужно внутри Шаблона прописать более двух параметров. Это делается через запятую

==============


template <class T1,class T2> //Шаблон функции с двумя параметрами

T1 max(T1 a, T2 b) //Функция max, тип функции равен типу первого принимаемого параметра

 {
  if (a>b) return a;
 else return b;
 }

void main()
{ 
 system("CLS");
  cout<<max(12,100)<<endl; //Возвращет тип int и равно 100
  cout<<max(120.222,100)<<endl; //Возвращает тип double и равно120.222
  cout<<max(10,55.5555)<<endl; //Возвращает тип int и равно 55 

 system("PAUSE");
}
==============
 В этом коде у невнимательного читателя может возникнуть вопрос: "А почему функция возвращает не 55.5555, а 55" - Ответ прост. Шаблоны функций очень похожи на прототипы функций. В качестве первого параметра вовнутрь функции передается целочисленное значение 10. Это 10 обрабатывается компилятором с помощью шаблона. В Шаблоне для типа первого параметра функции определен параметр Т1 (Он первый внутри угловых скобок). В добавок к этому сама функция max имеет тип, равный типу Т1, поэтому функция возвращает тот тип, который компилятор определяет из первого входного параметра вовнутрь функции.
 Изъясняясь короче

•    Из функции main вызывается функция max. В функцию передается 2 параметра
•    Функция max принимает два переданных в нее параметра
•    В Функции max для обработки данных происходит некоторый анализ при помощи шаблона
•    В шаблоне указано, что функция имеет два различных параметра, компилятор говорит понял, разберусь
•    Компилятор обработал данные с помощью шаблона и выбрал подходящий тип для каждого из параметров
•    Код написан таким образом, что тип функции max равен типу первого принимаемого параметра

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

===========
 #include <iostream.h>

template <class T>

void Show(T a)
{
 T n; //Переменная n. Тип переменной равен типу параметра а и определяется шаблоном
 n=a; //Присвоение в n значения a
cout<<n<<endl; //Что приняли, то и вывели на экран
}

void main()
{
 system("CLS");
   Show(10);
   Show(20.999);
   Show("HELLO");
 system("PAUSE");
}
===========
По факту это то же, что и первый приведенный код в этой статье. Просто кому-то может понадобиться использовать шаблон таким образом где внутри функции определяется какая-то локальная переменная, тип которой определяется с помощью шаблона или какие-то другие причины.

• Шаблоны функции позволяют вам объявлять типонезависимые или общие функции
• Если вы используете функцией только один какой-то тип, нет необходимости применять Шаблон
• Если параметрам функции требуется несколько различных типов, то Шаблон назначает каждому типу уникальный идентификатор, который компилятор в процессе компиляции обработает как переменную нужного типа

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

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

Постоянная ссылка

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

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

 Структуры очень похожи на массивы.
 Если массивы по определению могут содержать внутри себя множество однотипных элементов. 
 То внутри структур можно описать разное количество разнотипных элементов. А сами по себе структуры являются пользовательским типом данных.

===========================
int A[10]; // Десять элементов и все элементы типа int


struct MyStruct
{
 int A;
 char C[10];
};
MyStruct obj1[10]; //Десять элементов типа MyStruct
===========================
Внутри описанной структуры определено две переменные разных типов (int и char). Переменных внутри структуры может быть разное количество и каждому элементу может соответствовать нужный тип.  
Важно- В структуре весь интерес не в названии структуры, а в названии объекта. Т.е. после описания структуры обязательно создается минимум одна переменная тип которой есть имя структуры.
В приведенном примере такая переменная - obj1. Такие переменные называются объектами. Вот и выходит, что obj1 есть переменная типа MyStruct. При этом в приведенном коде переменная obj1 объявлена как массив переменных из десяти элементов. Каждый из этих десяти элементов имеет тип MyStruct и значит каждый элемент массива состоит из тех элементов, которые описаны внутри структуры.
  Возможно кому-то это поможет, а кто-то сочтет за запутанное и многословное пустословие. Не важно.
 MyStruct obj1[10]; //Массив из десяти структур. Или просто массив структур.
Так как внутри структуры описано две переменные, то будет использовано по два значения для каждого из элементов массива структур (сейчас увидите)


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

 
struct MyStruct
{
 int A;
 char C[10]; 
};

 void main()
{
 obj1[0].A=100;  //Первый элемент массива переменная int A
 strcpy(ob1[0].C,"12345"); //Первый элемент массива переменная char C[10]
}
===========================
 В этом коде в переменные массива присваиваются значения. Обращение к элементам структуры можно прописывать через точку. Чтобы работать с элементами массива, который является массивом структур, нужно транзитом через массив структур обращаться к тем переменным, которые описаны внутри структуры. Использовано два способа присваивания значений. Первый способ обычное присваивание через знак равно. Второй способ - это копирование строки в переменную.  Нетрудно заметить, что сначала написано имя объекта, потом индекс массива и через точку идет обращение к переменной описанной внутри структуры.

Иногда известно сколько элементов должен содержать массив и в задачах по программированию можно увидеть такие слова: "Создать массив из N структур" и т.п. В простых задачах ничего сложного нет. Часто студенты предлагают ввести N с клавиатуры и при вводе этого N создают массив структур из N элементов.

==================
MyStruct *obj1; //obj1 есть указатель на MyStruct;
int N; //N есть число элементов массива

cin>>N; //Присваивание в N значения

 obj1=new MyStruct[N]; //Динамическое выделение памяти под массив структур из N элементов
 //Некоторый код
delete []obj1; //Освобождение памяти
==================

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

 Продуктовый магазин представляет из себя одно целое. В магазине могут продавать разные продукты. У каждого продукта есть название, есть цена. В магазине есть разные продавцы, которые продают товар. К каждому продавцу подходит покупатель, который покупает товар. Можно долго и много расписывать что происходит на самом деле., но я остановлюсь на том что написал.
 Чтобы объяснить компилятору что нам нужно, стоит навести некоторый порядок в вышеизложенном.
 Я разобью на поэтапное изложение кода, чтобы большинство трудных читателей попробовали понять суть.

Продуктовый магазин
==================
struct Shop
{
 };
==================
Определились с обобщенным названием нашей структуры.

Всё что есть в магазине можно объединить под названием нужные данные.
==================
struct Shop
{
 char name[20]; //Название продукта 
 float cena; //Цена продукта 
 char prodav[30]; //Продавец
 char pokup[30]; //Покупатель
 int Date[3]; //Дата продажи
 };

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

После того как определились и описали нужную структуру обязательно создается переменная, тип которой есть имя структуры. Вводятся данные в элементы структуры. Нижеприведенный код это всё то что написано чуть выше.

=================
#include <iostream>
/*ОПИСЫВАЕМАЯ СТРУКТУРА*/
 struct Shop
 {
     char name[20];
     int cena;
     char prodav[30];
     char pokup[30];
     int date[3];
 };

/*ГЛАВНАЯ ФУНКЦИЯ*/
int main()
{
    int N;
    cout<<"Введи N: ";
    cin>>N;
      Shop *M1=new Shop[10]; //Выделение памяти под массив структур из 10 элементов

      delete []M1; //Освобождение памяти
    cin.get(); //Ожидание нажатия клавиши
    return 0;
}
=================
 Сам по себе такой код большого смысла не имеет, это всего лишь подготовительная часть для работы с массивом структур.

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

 void GetData(Shop *M,int N)
{
}
//Второй параметр - размерность массива


Ниже написан полноценный код, который содержит три функции. Главная функция и две функции, которые обрабатывают данные. В качестве обрабатываемых данных выступает массив структур. Одна функция обеспечивает ввод данных в массив структур. Вторая функция выводит массив структур на экран.

========================
#include <stdlib.h>
#include <iostream.h> 

/*ОПИСЫВАЕМАЯ СТРУКТУРА*/
struct Shop
{
   char Name[30];
   int Cena;
   char Prodav[30];
   char Pokup[30];
   int Date[3];
};


/*ФУНКЦИЯ ОБЕСПЕЧИВАЕТ ВЫВОД ДАННЫХ НА ЭКРАН*/
void ShowData(Shop *M,int N)
{
   for (int i=0;i<N;i++)
    {
     cout<<M[i].Name<<endl;
     cout<<M[i].Cena<<endl;
     cout<<M[i].Prodav<<endl;
     cout<<M[i].Pokup<<endl;
     cout<<M[i].Date[0]<<"."<<M[i].Date[1]<<"."<<M[i].Date[2]<<endl<<endl;
    }
}
/*ФУНКЦИЯ ЗАНОСИТ ДАННЫЕ В СТРУКТУРУ*/
void GetData(Shop *M,int N)
{
   cin.ignore();
     for (int i=0;i<N;i++)
      {
        cout<<"\n";
        cout<<"НАЗВАНИЕ: ";cin.getline(M[i].Name,30);

        cout<<"ЦЕНА: "; cin>>M[i].Cena;
        cin.ignore();

        cout<<"ПРОДАВЕЦ:        ";cin.getline(M[i].Prodav,30);
        cout<<"ПОКУПАТЕЛЬ: ";cin.getline(M[i].Pokup,30);

        cout<<"ДАТА ";
        cin>>M[i].Date[0];cin.ignore();
        cin>>M[i].Date[1];cin.ignore();
        cin>>M[i].Date[2];cin.ignore();
      }
}

/*ГЛАВНАЯ ФУНКЦИЯ*/  
void main()
{
    system("CLS");
      int N; cout<<"Введите  N: ";cin>>N;
      Shop *M=new Shop[N];
        GetData(M,N); //Ввод данных в массив структур
        ShowData(M,N); //Вывод массива структур на экран
     delete []M;
    system("PAUSE");
}
========================
 Стоит обратить внимание на cin.ignore(). Если убрать этот кусочек кода отовсюду, то можно увидеть не очень приятную ситуацию. Внутри потока может оставаться символ переноса строки и это служит нехорошую службу. Чтобы избежать некоторых проблем использован cin.ignore(); Отмечу что эта инструкция в приведенном коде прописана после ввода каждого не символьного типа данных.

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

============================
#include <stdlib.h>
#include <iostream.h>
/*ОПИСЫВАЕМАЯ СТРУКТУРА*/
struct Shop
{
 char Name[30];
 int Cena;
 char Prodav[30];
 char Pokup[30];
 int Date[3];
};


/*ФУНКЦИЯ ОБЕСПЕЧИВАЕТ ВЫВОД ДАННЫХ НА ЭКРАН*/
void ShowData(Shop *M,int N)
{
 system("CLS");
 cout<<"НАЗВАНИЕ          ЦЕНА          ПРОДАВЕЦ          ПОКУПАТЕЛЬ          ДАТА ПРОДАЖИ"<<"\n\n";
 for (int i=0;i<N;i++)
  {
   cout<<M[i].Name;
   cout<<"\r\033[20C";
   cout<<M[i].Cena;
   cout<<"\r\033[30C";
   cout<<M[i].Prodav;
   cout<<"\r\033[50C";
   cout<<M[i].Pokup;
   cout<<"\r\033[70C";
   cout<<M[i].Date[0]<<"."<<M[i].Date[1]<<"."<<M[i].Date[2]<<"\n";
  }
  cout<<"\n";
}


/*ФУНКЦИЯ ЗАНОСИТ ДАННЫЕ В СТРУКТУРУ*/ 
void GetData(Shop *M,int N)
{

 cin.ignore();
 for (int i=0;i<N;i++)
  {
   cout<<"\n";
   cout<<"НАЗВАНИЕ: ";cin.getline(M[i].Name,30);

   cout<<"ЦЕНА:  ";   cin>>M[i].Cena;
   cin.ignore();

   cout<<"ПРОДАВЕЦ:        ";cin.getline(M[i].Prodav,30);
   cout<<"ПОКУПАТЕЛЬ: ";cin.getline(M[i].Pokup,30);

   cout<<"ДАТА   ";
   cin>>M[i].Date[0];cin.ignore();
   cin>>M[i].Date[1];cin.ignore();
   cin>>M[i].Date[2];cin.ignore();
  }
}


 /*ГЛАВНАЯ ФУНКЦИЯ*/
void main()
{
 system("CLS");
    int N; cout<<"ВВЕДИ  N: ";cin>>N;
    Shop *M=new Shop[N]; //Динамическое выделение памяти под N структур
       GetData(M,N); //Занесение данных в структуры
       ShowData(M,N);
    delete []M; //Освобождение памяти
 system("PAUSE");
 }
 ===========================
 Почти такой же код как и вышеприведенный с некоторыми изменениями. Изменилась вся функция вывода данных на экран. Конечно можно было просто описать одну функцию, но кому-то такое описание сэкономит время.
cout<<"\r\033[50C"; 
Должен появится вопрос. Что это вообще такое. Это такой способ перемещения курсора внутри консоли.
\r                 -  Переносит курсор в начало строки
\033[50C     - Перенос курсора вправо на 50 позиций.  (http://www.cyberforum.ru/cpp-linux/thread325690.html)


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

Постоянная ссылка

•  если выделили память, то обязательно нужно её удалять.
•  Удалять память нужно только и только тогда, когда динамически созданный массив больше реально не нужен
•  Для передачи двумерного динамического массива в функцию удобно использовать указатель на указатель и при передаче его в функцию, в функцию стоит передавать размерность массива 

Постоянная ссылка

Где-то должно быть описано уже, но искать тяжело. У начинающих может возникнуть вопрос: "Как вывести текст файла на экран". Дело не хитрое, но если  начинающих принудительно заставляют использовать старые версии компиляторов, то тут могут возникнуть проблемы. Думаю эта тема достаточно актуальна.

Чтобы компилятор мог прочитать русский текст, нужно записывать в файл текст таким шрифтом, который компилятор для русского текста использует. Если пытаться прочитать текст, написанный привычными большинству шрифтами, то вместо русских букв можно наблюдать абракадабру. Чтобы этой абракадабры избежать, я создам один файл с двумя функциями. Кому какая функция будет нужна решайте сами. Первая функция вводит информацию в текстовый файл, вторая функция читает информацию из текстового файла. При необходимости ненужную функцию легко убрать.

=========================
#include <fstream.h>

const N=256; //Константный размер строки 
char FName="C:\MyFile.txt"; //Путь к файлу 

/*Вывод текста из файла на экран*/
void ReadFile()
 {
  cout<<endl<<"ReadFile:  "; //Для красоты 
  char S[N]={""}; //В S будут считываться строки 

      ifstream in1(FName); //Открыли файл для чтения
         while (!in1.eof()) //Будем читать информацию пока не дойдем до конца файла
           {
             in1.getline(S,N); //Построчное считывание информации в S 
             cout<<S<<endl; //Вывод очередной строки на экран 
           }
       in1.close();  //Закрыли открытый файл
}

/*Ввод текста в файл*/
void CreateFile() 
{
 cout<<"Create File:  "<<endl; //Для красоты
 char S[N]={""}; //В S будет считываться строка 
 int count=0; //Число строк для ввода в файл

 cout<<"Strok budet:  " ;
 cin>>count; //Определили сколько строк вводить

     ofstream out1(FName);  //Открыли файл для записи
   for (int i=0;i<count+1;i++)  //Цикл по количеству нужных строк
    {
      cin.getline(S,N); //Запоминаем в S то что ввели с клавиатуры
      out1>>S>>endl; //Записали S в файл и дописали перенос строки
    }
  out1.close();
}


void main()
 {
   clrscr();
     CreateFile(); //Функция записывает строки в файл
     WriteFile();   //Функция читает строки из файла и выводит их на экран
   getch();
 }
=========================
По приведенному коду говорить почти нечего. Код говорит сам за себя.
  while (!in1.eof()) - Читается как: "До тех пока не достигнут конец файла, выполнять..."
Первой была написана функция по вводу текста в файл, а после нее написана функция чтения текста из файла и вывода информации на экра. Так как у меня с русской кодировкой проблем нет, то записывая строки русским шрифтом, текст мне выводился русским.

Примечание:
 Для тех кто использует DosBox Borland C++ 3.1, предложенный в этом блоге, скорее всего переход на русские символы правая клавиша ctrl. Если в качестве пути файла указывать "C:\\...", то файл записывается в папку где установлена DosBox С++. (У меня C:\BORLAND).

Постоянная ссылка