1. Увод


"A little inaccuracy sometimes saves tons
of explanation."
Saki (H. H. Munroe)


Компютри и програмиране.
Всяка програма "казва" на компютъра редицата от стъпки, необходими за да се изпълни дадена задача. Процесът на проектиране и реализиране на програмите се нарича компютърно програмиране. Дейността програмиране е централна в компютърната наука.
За да работи един човек с компютър не е необходимо да бъде програ- мист. Той може да използва (като потребител) написани вече програми и програмни системи. Повечето хора, работещи с компютър, правят именно това. Знанията по програмиране за потребителя на готови програми му помагат по-пълно да използва възможностите им и да увеличи ефективността на своята работа.

Езици за програмиране и транслатори.
** Езици за програмиране от ниско ниво.
На най-ниско ниво инструкциите към компютъра са изключително прости. Процесорът изпълнява така наречените машинни инструкции.
Пример:
1. Премести съдържанието на клетка 40000 от паметта в регистъра AX.
2. Извади 100 от регистъра AX.
3. Ако резултатът е положителен, премини към инструкцията, намираща се в клетка 11280 от паметта.
Инструкциите (машинен език) за процесор Intel 80386 са:
161 40000 45 100 127 11280
Същото на езика Асемблер може да се напише така:
MOV AX, [40000]
SUB AX, 100
JG 11280
MOV (move) означава премести; SUB (subtract) - извади; JG (jump if greater than) - ако резултатът е по-голям от 0, премини към ... Използването на буквени имена вместо адреси от паметта прави програмата по-лесна за четене:
MOV AX, [INT_RATE]
SUB AX, 100
JG INT_ERROR
Езиците от ниско ниво зависят от процесора. Например има разлики в езика Асемблер за процесор Intel 80386 и процесор Motorola 68000.
** Езици за програмиране от високо ниво.
При тези езици програмистът описва схематично основните стъпки (алгоритъма), които трябва да се изпълнят за решаване на дадена задача, а специална програма, наречена транслатор (преводач), превежда това описание в машинни инструкции за конкретен процесор. Транслаторите са два вида - компилатори, които създават файл с кода на програмата на машинен език и интерпретатори, които направо подават на процесора (за изпълнение) поредицата от машинни команди.
Същият пример би изглеждал така на C++:
if (int_rate > 100) message_box("Interest rate error");
и на Паскал:
if int_rate > 100 then writeln('Interest rate error');
Съвременните програмни езици не се отличават по функционалност - по принцип всеки алгоритъм може да се програмира на всеки език за програмиране - разликата е в усилията на програмиста и в ефективността на получената програма. Днес съществуват много програмни езици с различно предназначение. Ето по-известните от тях:
- FORTRAN - главно за реализиране на числени алгоритми (счита се за остарял език);
- Algol 60 - главно за описание на алгоритми;
- ADA - разработен и използван в американската армия;
- Pascal - подходящ за обучение по програмиране;
- Modula 3 - обектно-ориентиран език (модулно програмиране);
- Delphi - обектно-ориентиран език, разширение на езика Pascal;
- Simula - обектно-ориентиран език за симулационно моделиране;
- C - универсален език, свързан с операционна система Unix;
- С++ - обектно-ориентиран език, разширение на езика С;
- Lisp, Prolog - езици за функционално програмиране;
- Basic - език, създаден за първите персонални компютри;
- Java - съвременен обектно-ориентиран език главно за мрежово програмиране.
Съществуват и по-специализирани езици, създанени с точно определена цел. Например:
- PHP, ASP - езици за създаване на WEB страници;
- SQL - език за работа с бази данни;
- Perl - скриптов език - за управление на операционни системи.
"Планираните" езици (Pascal, ADA, Modula 3) са създадени от един човек или от група хора с определена цел - отделните им компоненти са логически свързани и могат лесно да бъдат комбинирани.
"Разрасналите се" езици (C/C++, Basic) се развиват във времето, като различни хора добавят нови елементи в езика и същевременно запазват всички стари конструкции, за да могат написани вече програми на старите версии на езика да се транслират и с новите компилатори, създадени за новите версии на езика.
** История на езика С++.
* Езикът С се създава и развива заедно с операционната система UNIX. Първата версия е създадена през 1973 г. от Денис Ричи. Езикът се развива интензивно и през 1977 г. UNIX е пренаписана на С. Стандартна версия на езика е установена през 1989 година.
* Езикът С++ е създаден от Бьорн Страуструп 1983 г. като към езика С са добавени нови елементи. Всъщност възниква нов обектно-ориентиран език, който веднага получава много широко разпространение. Стандартизацията на езика завършва през 1998 година, като книгата на Страуструп e всъщност този стандарт.
** Системи (среди) за програмиране - обикновено се състоят от текстов редактор, компилатор, библиотеки и система за проверка на програмите (debug). За С/С++ по-известните среди за програмиране са:
- Turbo C/C++ (Borland C++ 3.5, 4.5, 5)- удобен за начинаещи програмисти, има help за езика и добър дебъгер; с библиотеките на К. Хорсман могат да се компилират всички примери от книгата и този сборник;
- Borland C/C++ Builder - поддържа С++ стандарт, удобен за по-напреднали програмисти;
- MS Visual C++ - продукт на Майкрософт, поддържа С++ стандарт;
- Dev C++ - поддържа С++ стандарт, няма help за езика и удобен дебъгер;
- DJGPP е среда за 32-битови програми под DOS. Чрез нея могат да се стартират почти всички програми за операционната система Линукс, които не използват многозадачните, многопотребителските и графичните му възможности.
** Отделни компилатори:
- Borland C++ Compiler 5.5 (BCC) - бърз 32-битов оптимизиран компилатор; поддържа С++ стандарт;
- GCC е GNU компилатор, който поддържа най-новите версии (стандарти) на езиците C, C++, Objective-C, Fortran, Java и Ada, също така и библиотеките за тези езици (libstdc++, libgcj,...).

Проста програма - компилиране и грешки.

// hello.cpp       /*Име на файла, съдържащ текста на програмата*/
#include <iostream>       /*Директива на препроцесора*/
using namespace std;       /*Стандартно пространство на имена*/
      
int main()       /*Главна функция */
{ cout << "Hello, World!
";       /*Оператор за потоков изход*/
return 0;       /*Връща на операционната система числото 0*/
}       
Hello, World!

По-важни характеристики на синтаксиса на езика:
- Азбуката на езика се състои от всички символи от клавиатурата на компютъра.
- Поредица от букви и цифри образува име, разделители между имената са интервал или символ, който не е буква или цифра.
- С++ различава малки от главни букви, напр. имената main и Main са различни.
- Програмата се разполага линейно - по редове (няма горни и долни индекси).
- Програмата се състои от оператори - всеки оператор завършва с точка и запетая ";".
- Един оператор може да се разположи на два и повече реда; няколко оператора може да се разположат на един ред - добрия стил на програмиране изисква един оператор да се пише на един ред (освен ако няма съществена причина за противното).
** Процесът от написване до изпълнение на програмата се състои от следните стъпки:
I стъпка: Написване на текста на програмата; използва се текстов редактор, който създава текстов файл - изходен код (source code) [напр. hello.cpp].
II стъпка: Компилиране на програмата; извършва се от компилатора, който създава файл - обектен код (object code) [напр. hello.o или hello.obj].
III стъпка: Свързване на програмата; извършва се от свързваща програма (linker), която създава изпълним файл [напр. hello.exe или hello или a].
IV стъпка: Изпълнение на програмата; операционната система или програмната система стартира създадения изпълним файл.
** Видове грешки.
* Грешка по време на компилация (синтактична грешка) - неправилно написана конструкция от езика. Компилаторът не може да продължи, дава съобщение за грешка, програмистът трябва да поправи грешката и отново да стартира компилатора.
* Грешка по време на изпълнение (Run-time error) - процесорът не може да изпълни някоя инструкция, напр. делене на 0. Операционната система прекратява изпълнението на програмата.
* Грешка в алгоритъма (логическа грешка) - програмата работи, но дава грешни резултати.

Алгоритми.
Да разгледаме следния пример: Внасяме в банка 10000 лева с 6% годишна лихва. Влогът се олихвява месечно. След колко години сумата по сметката ще стане двойно по-голяма?

Месец       Сума        Пресмятане
0       10000.00       
1       10050.00       =10000.00*1.005
2       10100.25       =10050.00*1.005
3       10150.75       =10100.25*1.005
4       10201.51       =10150.75*1.005
..       ...       ...

1. Започнете с таблицата:
Месец       Сума
0       10000
2. Повтаряйте стъпки 2а-2в докато съдържанието на сметката е под 20000 лева.
2а. Добавете нов ред към таблицата.
2б. В първата колона на този ред поставете число, с 1 по-голямо от това на горния ред.
2в. Във втората колона на същия ред поставете числото от горния ред (същата колона), умножено с 1.005.
3. Разделете последното число от първата колона на 12.
Алгоритъм е описание на стъпките, необходими за решаването на някаква задача, което е еднозначно, изпълнимо и винаги завършва. Описанието може да бъде текст, блок-схема или програма на език за програмиране от високо ниво.

Бройни системи.
Най-често използваните бройни системи са:
* Десетична бройна система - цифри: 0,1,2,3,4,5,6,7,8,9
15210 = 2.100 + 5.101 + 1.102 =152
* Двоична бройна система - цифри: 0,1
101112 = 1.20 + 1.21 + 1.22 + 0.23 + 1.24 = 1+2+4+16 = 23
* Шестнадесетична бройна система - цифри: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
7A116 = 1.160 + 10.161 + 7.162 = 1+160+1792 = 1953

Примерите показват превръщане ва числата от двоична или шестнадесетична бройна система в десетична бройна система. Обратното превръщане става, като се дели многократно числото на основата на бройната система. Остатъка при всяко деление представлява една цифра на числото в бройната система.
Например:

частно       остатък       цифра
23       1       1
11       1       1
5       1       1
2       0       0
1       1       1
      
частно       остатък       цифра
1953       1       1
122       10       A
7       7       7
Превъщането от двоична в шестнадесетична бройна система и обратно става много лесно, защото 16 = 24. Просто 4 двоични цифри образуват една шестнадесетична цифра. Например:
За 11110101000101102 имаме 1111 | 0101 | 0001 | 0110 и получаваме
11112 = 1510 = F16, 01012 = 610 = 616, 00012 = 110 = 116, 01112 = 710 = 716, което е F61716.
 P.S. Инфото  е от тук

Вмъквам задачата която ме интересува. В Паскал такива задачи се решаваха с типизирани файлове - файл от базов тип запис. Какъв е техния аналог в С или какъв е подхода за решаваето на такива задачи. Ето програмката:                              (Благодаря за цялата поместена информация за двата езика

#include <iostream>
#include <fstream>
#include <algorithm>
using namespace std;
const int n=3;
struct danni
 {
        string ime;
        int nomer;
}z;    
 fstream g;
 danni a[20];
 int i,n1;
void ftom(danni a[], int &n2)
{
     g.open("opit1.txt",ios::in);
     int i=0;
     while(g>>z.ime>>z.nomer)
      {
        a.ime=z.ime;
        a.nomer=z.nomer;
        i++;
      }n2=i;
     g.close();
     g.clear();
    
 }
void sortirane()
{
     ftom(a,n1);
     string min;
     int ind;
     for (int i=0;i<n1-1;i++)
     {
       min=a.ime;ind=i;
       for(int j=i+1;j<n1;j++)
       if (a[j].ime<min)
         {min=a[j].ime;ind=j;}
       z=a[ind];a[ind]=a;a=z;
       }
     for(int i=0;i<n1;i++)
     {cout<<a.ime<<"  "<<a.nomer<<endl;}
     system("pause");
 }

bool compi(const danni &d, const danni &c)
{ if(d.nomer<c.nomer) return true;
  if(d.nomer>c.nomer) return false;
  return false;
}
void sorti()
{
    ftom(a,n1);
    sort(a,a+n1,compi);
    for(int i=0;i<n1;i++)
     {cout<<a.ime<<"  "<<a.nomer<<endl;}
    system("pause");

 }
 void writef()
  {
    g.open("opit1.txt",ios::out);
    for (int i=0;i<n;i++)
     {cout<<"Vavedi ime:";cin>>z.ime;
      g<<z.ime<<endl;
      cout<<"Vavedi nomer:";cin>>z.nomer;
      g<<z.nomer<<endl;
     }
    g.close();
  }
 void readf()
  {
    g.open("opit1.txt",ios::in);
    while(g>>z.ime>>z.nomer)
      {
        cout<<z.ime<<"  "<<z.nomer<<endl;
      }
    cin.get();
    g.close();
    g.clear();
  }
 void addf()
   {
     g.open ("opit1.txt",ios::out|ios::app);
     cout<<"Vavedi ime:";cin>>z.ime;
     cout<<"Vavedi nomer:";cin>>z.nomer;
     g<<z.nomer<<endl;
     g.close();
}  
void sortirovki()
{
     int k1;
     do
     {
        system("cls");
        cout<<"1. sortirane po ime"<<endl;
        cout<<"2. sortirane s metod SORT po nomer"<<endl;
        cout<<"3. kraj na sortiraneto"<<endl;
        cout<<"Izberi ot 1 do 3:";cin>>k1;
        switch (k1)
         {
               case 1: sortirane();break;
               case 2: sorti();break;
               case 3: exit;
         }    
      }while (k1 != 3);
 }

int main()
{
    int k;
      {
        system("cls");
        cout<<"Menu"<<endl;
        cout<<"1. Sazdavane"<<endl;
        cout<<"2. Chetene"<<endl;
        cout<<"3. Dobavjane"<<endl;
        cout<<"4. Sortirane"<<endl;
        cout<<"5. Kraj"<<endl<<endl;
        cout<<"Izberi ot 1 do 5:";cin>>k;cin.get();
        switch (k)
         {case 1:writef();break;
          case 2:readf();break;
          case 3:addf();break;
          case 4:sortirovki();break;
          case 5:exit;
          }
     } while (k != 5);
      return 0;
}

       На Паскалския type съответствува struct и още : record => { , end => } . Полетата се описват по същия начин.

      Файловете в C++ са текстови и препоръчвам да не използвате първоначално кирилица.

      Вашата програма работи, но е необходимо да се направят някои синтактични корекции. Аз съм ги направил и помествам пълния текст, който работи вярно. Ако имате някакви въпроси попитайте.

#include "stdafx.h"

#include <iostream>

#include <fstream>

#include <string> //добавено от мен

#include <algorithm>

using namespace std;

const int n=3;

int i,n1;

a.ime=z.ime; //индекса е добавен от мен

a.nomer=z.nomer; //индекса е добавен от мен

int ind; //това е известния метод за сортиране чрез пряк избор

min=a.ime;ind=i; //индекса е добавен от мен - приема се i-тия елемент за минимален

z=a[ind];a[ind]=a;a=z;// индекса е добавен от мен

{cout<<a.ime<<" "<<a.nomer<<endl;}//индекса е добавен от мен

bool compi(const danni &d, const danni &c) //тази функция е необходима за сортировката

if(d.nomer>c.nomer) return false;

void sorti()//тази сортировка е от библиотеката algorithm

{cout<<a.ime<<" "<<a.nomer<<endl;}//индекса е добавен от мен

do

case 2: sorti();break;

{ int k;

do

{case 1:writef();break;

case 3:addf();break;

} while (k != 5);

Извинявам се, че не съм обяснила точно какво ме интересува. Програмата в написания вариант работи при мене (сега забелязах, че са се появили някакви икони - крушки, не съм ги слагала съзнателно, а поправките, които сте нанесли  в началото при мен не сработиха). По тази програма нямам въпроси. Това което ме интересува, как този файл - "opit1.txt", който е от текстов тип да бъде заместен с файл, който съответства на типизиран файл в Паскал и програмата да има същото действие. Тоест какъв е аналога на типизираните Паскалски файлове в С++.

           По - долу ще посоча желаните промени от Вас. В C++ освен с текстови файлове се работи и с двоични - те се разглеждат като последователност от байтове. Паскалските типизирани файлове се състоят от записи с фиксирана дължина. Поради тази причини и в C++ трябва да се работи с фиксирана дължина. Това налага да се откажен от типа string и да го заменим с char ime[20]. С посочения начин на четене (g.read()), се прочитат фиксиран брой байта от файла и се поставят в z. При записване същият брой байта се взимат от z и се записват във файла. Определянето на типа на файла като двоичен става с добавянето на ios::binary при отварянето на файла. Това което по - долу липсва остава непроменено. Тип char налага използване на функции за сравняване на низове и копиране на низове. Ако нещо не работи може отново да попитате. Според мен програмата ще задоволи Вашите желания

char ime[20]; //редактирано

int i,n1;

g.open("opit1.bin",ios::in|ios::binary); //редактирано

//while(g>>z.ime>>z.nomer)

while(g.read((char*)&z,sizeof(z))) //редактирано

{ a=z; // добавено

// a.ime=z.ime;

// a.nomer=z.nomer;

//string min;

int ind; //това е известния метод за сортиране чрез пряк избор

//min=a.ime;

strcpy(min,a.ime); //функция за присвояване/копиране

//if (a[j].ime<min)

if (strcmp(min,a[j].ime)) //функция за сравняване

{//min=a[j].ime;

strcpy(min,a[j].ime); //функция за копиране

g.open("opit1.bin",ios::out|ios::binary);//редактирано

//g<<z.ime<<endl;

// g<<z.nomer<<endl;

g.write((char*)&z,sizeof(z)); // записване във файл

g.open("opit1.bin",ios::in|ios::binary); // редактирано

while(g.read((char*)&z,sizeof(z))) // четене от файл

g.open ("opit1.bin",ios::out|ios::app|ios::binary);//редактирано

// g<<z.ime<<endl;

// g<<z.nomer<<endl;

g.write((char *)&z,sizeof(z)); //записване във файл

Много Ви благодаря за нанесените корекции. Точно това исках да постигна. В интерес на истината успях да намеря и помощ от колеги и стигнах до същия резултат. Остана ми единствено неясно обяснението за синтаксиса на операторите  g.write((char *)&z,sizeof(z)); и g.read((char *)&z,sizeof(z)). От обясненията това трябва да означава, че се записват (четат) sizeof(z) на брой байта от адрес определен чрез (char *)&z.

Другият ми въпрос е за това дали ангажираните адреси от паметта изискват вътрешно (от програмата) освобождаване, за да не се стига до конфликти с други програми или след приключване на програмата заеманото място се освобождава автоматично.

        Не е необходимо да се освобождава паметта. В началния вариант на програмата Вие работите с променливата z, Тя си остава същата, а нейния адрес е &Z. Изразът (char *) означава данните от посочения адрес да се преобразуват в символи (байтове)  и така да се запишат или четат. По - големи подробности бихте могил да намерите в "Програмиране на C++" - част втора от Магдалина Тодорова стр.420-457. Там ще намерите:  отваряне на файлове, файлове с последователен достъп, файлове с пряк достъп-включване на запис, изтриване на запис, актуализиране на запис, последователно четене на файл с пряк достъп.

     Богдан Христов 

Благодаря за отговорите и съветите. Ще потърся този учебник.

Това е поздрав с музика http://www.youtube.com/watch?v=2FmcKBdEJ_U&feature=related 

Оказа се, че програмата работи и без указване на режим: "ios::binary". Това е когато се използват член-функциите write и read. Кога е асолютно необходимо да се укаже този режим?

         Ако не използвате "ios:binary" файлът, който създавате е текстов. Съдържанието може да разгледате с Notepad. Вие не искахте да работите с текстов файл. Цитирам Хърбърт Шилдт "По подразбиране всички файлове се отварят в текстов режим. В текстов режим, се правят различни конвертирания на символи . Когато файлът е отворен в двоичен режим, такива транслации не се правят. Всеки файл, който съдържа форматиран текст или данни в суров вид, може да бъде отворен както в двоичен, така и в текстов режим. Единствената разлика е това, дали ще се правят преобразования на знакове."

Здравейте колеги,

темата ме заинтересува и мен като учител по Информатика в ПМГ с профил Информатика. За първа година преподавам С++ и срещнах трудност с файлове.

Може ли някой да ми каже как се създава тектов файл като се чете от клавиатуката до Ctrl+z?

Този код създава файл с име Opit.txt, като след Enter (тоест на нов ред) се използва комбинацията Ctrl+Z. Взет е от учебника на Магдалина Тодорова "Програмиране на С++", част втора, изд. Сиела 

#include <iostream>
#include <fstream>
using namespace std;
const int n=3;
int main()
{ char dumi[50];
  ofstream f("opit.txt",ios::out);
  cout<<">";
  while (cin.getline(dumi,50))
  {f<<dumi<<endl;
   cout<<">";
  }
  f.close();
  return 0;
}

#include <iostream>

#include <fstream>

#include <conio.h>

using namespace std;

do{ch=getche();

Здравейте, 

Изчетох внимателно всичко написано.

Искам да запитам някой може ли да ми обясни как се обработват "многонишкови процеси" в C++?

Предварително благодаря за съдействието.

С уважение

Avatara

        До сега не ми се е налагало да използвам многонишково програмиране. Струва ми се, че в С++ е достатъчно трудно да се работи.

       Ако трябва да напиша такава програма, ще използвам С#, защото има откъде да се прочете - това е глава 17 от втората част на книгата на Светлин Наков.