Пример: Преобразуване на момент от време в низ. В САЩ има два формата за записване на време с разлика в часовете:
- am/pm - денонощието започва с 12 am следват 1-11 am, 12 pm и 1-11 pm.
- military - часовете са от 00 до 23.
// readtime.cpp
#include <iostream>
#include <sstream>
using namespace std;

string int_to_string(int n)
{ ostringstream outstr;
  outstr << n;
  return outstr.str();
}

void read_time(int &hours, int &minutes)
{ string line;
  getline(cin, line);
  istringstream instr(line);
  instr >> hours;
  minutes = 0;
  char ch;
  instr.get(ch);
  if (ch == ':') instr >> minutes;
  else           instr.unget();

  string suffix;
  instr >> suffix;
  if (suffix == "pm") hours += 12;
}

string time_to_string(int hours, int minutes, bool am_pm)
{ string suffix;
  if (am_pm)
  { if (hours < 12) suffix = "am";
    else { suffix = "pm"; hours -= 12; }
    if (hours == 0) hours = 12;
  }
  string result = int_to_string(hours) + ":";
  if (minutes < 10) result = result + "0";
  result = result + int_to_string(minutes);
  if (am_pm) result = result + " " + suffix;
  return result;
}

int main()
{ cout << "Please enter the time: ";
  int hours, minutes;
  read_time(hours, minutes);

  cout << "Using am/pm:   " << time_to_string(hours, minutes, true) << "\n";
  cout << "Military time: " << time_to_string(hours, minutes, false) << "\n";
  return 0;
}

Аргументи от командния ред.
* Определение и използване.
    Операционните системи UNIX и DOS могат да предават данни от командния ред за стартиране на програма на С и С++ на самата програма. За тази цел главната функция main може да има два формални параметри - int argc и char* argv[]. Следващият пример илюстрира тази възможност.
// simple.cpp
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
   for (int i=0; i<argc; i++)
       cout << "argv[" << i << "]=" << argv[i] << endl;
   return 0;

* Шифър на Цезар.
    Шифрирането се състои в замяна на буква от даден (изходен) текст с друга буква, която се намира е след key букви в азбуката. Дешифрирането на шифриран текст се състои във възстановяване на изходното съобщение.
    Програмта работи със следните аргументи от командния ред:
- флаг -d (незадължителен) за работа на програмата по дешифриране;
- флаг -k<число> (незадължителен) за задаване на ключ (по подразбиране ключът е 3);
- име на входен файл;
- име на изходен файл.

// ceasar.cpp
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
using namespace std;

void usage(string program_name)
{ cout << "Usage: " << program_name
       << " [-d] [-kn] infile outfile\n";
  exit(1);
}

void open_file_error(string filename)
{ cout << "Error opening file " << filename << "\n";
  exit(1);
}

int remainder(int a, int n)
{ if (a >= 0) return a % n;
  else        return n - 1 - (-a - 1) % n;
}

char encrypt(char ch, int k)
{ const int NLETTER = 26;
  if ('A' <= ch && ch <= 'Z')
     return static_cast<char>('A' + remainder(ch-'A'+k, NLETTER));
  if ('a' <= ch && ch <= 'z')
     return static_cast<char>('a' + remainder(ch-'a'+k, NLETTER));
  return ch;
}

void encrypt_file(ifstream& in, ofstream& out, int k)
{ char ch;
  while (in.get(ch)) out.put(encrypt(ch, k));
}

int string_to_int(string s)
{ istringstream instr(s);
  int n;
  instr >> n;
  return n;
}

int main(int argc, char* argv[])
{ bool decrypt = false;
  int key = 3;
  int nfile = 0;
  ifstream infile;
  ofstream outfile;

  if (argc<3 or argc>5) usage(string(argv[0]));
  for (int i = 1; i < argc; i++)
  { string arg = string(argv[i]);
    if (arg.length() >= 2 and arg[0] == '-')
    { char option = arg[1];
      if (option == 'd') decrypt = true;
      else if (option == 'k')
        key = string_to_int(arg.substr(2, arg.length() - 2));
    }
    else
    { nfile++;
      if (nfile == 1)
      { infile.open(arg.c_str());
        if (infile.fail()) open_file_error(arg);
      }
      else if (nfile == 2)
      { outfile.open(arg.c_str());
        if (outfile.fail()) open_file_error(arg);
      }
    }
   }
   if(nfile != 2) usage(string(argv[0]));
   if (decrypt) key = -key;
   encrypt_file(infile, outfile, key);
   infile.close();
   outfile.close();
   return 0;
}

Изпълнение на програмата:

Файл input.txt:

Изпълнение на програмата:

Изпълнение на програмата:

Изпълнение на програмата:

• get - позиция за четене,
• put - позиция за писане.

fs.seekg(0, ios::end);
long file_length = fs.tellg();

* Програма за четене на файлови записи, съдържащи име на служител и заплата и промяна на заплатата на даден служител. 

Примерен файл: employee.dat

// database.cpp
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
using namespace std; 

#include "ccc_empl.h"

const int NEWLINE_LENGTH = 2; /* или 1 за Unix */
const int RECORD_SIZE = 30 + 10 + NEWLINE_LENGTH;

double string_to_double(string s)
{ istringstream instr(s);
  double x;
  instr >> x;
  return x;
}

void raise_salary(Employee &e, double percent)
{ double new_salary = e.get_salary()*(1 + percent/100);
  e.set_salary(new_salary);
}

void read_employee(Employee &e, fstream &fs)
{ string line;
  getline(fs, line);
  if (fs.fail()) return;
  string name = line.substr(0, 30);
  double salary = string_to_double(line.substr(30, 10));
  e = Employee(name, salary);
}

void write_employee(Employee e, fstream &fs)
{ fs << e.get_name()
     << setw(10 + (30 - e.get_name().length()))
     << fixed << setprecision(2)
     << e.get_salary() << "\n";
}

int main()
{ cout << "Please enter the data file name: ";
  string filename;
  cin >> filename;
  fstream fs;
  fs.open(filename.c_str());
  fs.seekg(0, ios::end);
  int nrecord = fs.tellg()/RECORD_SIZE;

  cout << "Please enter the record to update: (0 - "
       << nrecord - 1 << ") ";
  int pos;
  cin >> pos;

  const double SALARY_CHANGE = 5.0;
  Employee e;
  fs.seekg(pos*RECORD_SIZE, ios::beg);
  read_employee(e, fs);
  raise_salary(e, SALARY_CHANGE);
  fs.seekp(pos*RECORD_SIZE, ios::beg);
  write_employee(e, fs);

  fs.close();
  return 0;
}
Файл data.txt преди изпълнение на програмата:

Рекурсия. Триъгълни числа

• В този пример, ние ще разгледаме триъгълни форми, като тази, показана тук:

  []
  [][]
  [][][]

• n-тото триъгълно число е лицето на триъгълник с ширина n, като предполагаме, че всяко[] има лице 1.
• От картинката - третото триъгълно число е 6.
• Ето интерфейса на класа, който ще разработваме:

  class Triangle {
  public:
     Triangle(int w);
     int get_area() const;
  private:
     int width;
  };
  Triangle::Triangle(int w)
  { width = w; }

• Ако ширината на триъгълника е 1, тогава той има площ 1.

  []
  
  int Triangle::get_area()
  { if (width == 1) return 1;
     . . .
  }

• За решаване на общия случай, разглеждаме тази картинка:

  []
  [][]
  [][][]
  [][][][]

• Да мислим за лицето на по-големия триъгълник като

  smaller_area + width

• За да намерим по-малкото лице, ние правим по-малък триъгълник! 

  int Triangle::get_area()
  {  if (width == 1) return 1;
     Triangle smaller_triangle(width - 1);
     int smaller_area = smaller_triangle.get_area();
     return smaller_area + width;
  }

• Here's how the area is computed for a triangle of width 4.
  • The get_area function makes a smaller triangle of width 3.
    • It calls get_area on that triangle.
      • That function makes a smaller triangle of width 2.
        • It calls get_area on that triangle.
          • That function make a smaller triangle of width 1.
          • It calls get_area on that triangle.
        • That function returns 1.
      • The function returns smaller_area + width = 1 + 2 = 3.
    • The function returns smaller_area + width = 3 + 3 = 6.
  • The function returns smaller_area + width = 6 + 4 = 10.

• Техниката на изразяване на решение на дадена задача от гледна точка на решение за по-малка версия на същата задача се нарича рекурсия.
• Има две основни изисквания, които да направят рекурсията успешна:
  • Всяко рекурсивно повикване трябва да се опрости изчислението по някакъв начин.
  • Трябва да има специален случай, където да се извършат пряко най-простите изчисления.
• HТук get_area get_area извиква сама себе си отново с по-малки и по-малки широчини, достигайки в крайна сметка широчина 1.

#include <iostream>
using namespace std
/**
   A class that describes triangle shapes like this:
   []
   [][]
   [][][]
   . . .
*/   
class Triangle {
public:
   Triangle(int w);
   int get_area() const;
private:
   int width;  
};
/**
   Constructs a triangle with a given width.
   @param w the width of the triangle base
*/
Triangle::Triangle(int w)
{  width = w;  }
/**
   Computes the area of the triangle shape.
   @return the area
*/
int Triangle::get_area() const
{  if (width == 1) return 1;
   Triangle smaller_triangle(width - 1);
   int smaller_area = smaller_triangle.get_area();
   return smaller_area + width;
}

int main()
{  Triangle t(4);
   cout << "Area: " << t.get_area() << endl;
   return 0;
}

• Рекурсия не е наистина необходима, за да се реши тази задача. Това може да бъде направено с помощта на:
  • прост цикъл:

    double area = 0;
    for (int i = 1; i <= width; i++) area = area + 1;

  • формула:

    width * (width + 1) / 2

Рекурсия. Пермутации

• Ще разработим функция, която връща всички пермутации на даден низ.
• Пермутация е просто пренареждане на буквите на низа:

  "eat"
  "eta"
  "aet"
  "ate"
  "tea"
  "tae"

• Ако низа има n букви, то броят на пермутациите се дава с функцията факториел:

  n! = 1 x 2 x 3 x . . . x n

• За да се пресментне стойността на функцията n! може да се използва цикъл, но има и рекурентна формула:

  n! = (n - 1)! x n 

• Обичайно се определя

  1! = 1
  0! = 1

• Следователно може да се приложи рекурсивно факториел функция (която дава броя на пермутациите), както следва:

  int factorial(int n)
  {  if (n == 0) return 1;
     int smaller_factorial = factorial(n - 1);
     int result = smaller_factorial * n;
     return result;
  }

• Ще разработим функция, която генерира всички пермутации на една дума.

  vector<string> generate_permutations(string word);

• Следният код показва всички пермутации на низа "eat":

  vector<string> v = generate_permutations("eat");
  for(int i = 0; i < v.size(); i++)
     cout << v[i] << "\n";

• За генериране на всички пермутации рекурсивно, генерираме пермутациите, които започват с буквата 'e', на тези, които започват на 'a', а след това тези, които започват 't'.
• Използваме рекурсията за генериране на всички пермутации на по-кратки (двубуквени низова).
  • "at" "ta"
  • "et" "te"
  • "ae" "ea"
• Добавяме първите букви за да намерим вси1ки трибуквени пермутации.
  • "eat" "eta"
  • "aet" "ate"
  • "tae" "tea"

• За да реализираме идеите в предишния пример, прилагаме един цикъл, които създава по-кратка дума, която пропуска текущата позиция.

  vector<string> generate_permutations(string word)
  {  vector<string> result;
     ...
     for (int i = 0; i < word.length(); i++)
     {     string shorter_word = word.substr(0, i)
           	+ word.substr(i + 1, word.length() - i - 1);
        ...
     }
     return result;
  }

• Следващата стъпка е да се намерят пермутациите на по-кратката дума.

  vector<string> shorter_permutations
     = generate_permutations(shorter_word);

• За всяка от късите пермутации, добавяме пропуснатата буква.

  for(int j = 0; j < shorter_permutations.size(); j++)
  {  string longer_word = word[i] + shorter_permutations[j];
     result.push_back(longer_word);
  }

• Трябва да добавим точка за край на рекурсията, т.е. специалния случай на дума с дължина 1.

  if (word.length() == 1)
  {  result.push_back(word);
     return result;
  }

#include <iostream>
#include <string>
#include <vector>
using namespace std;
/**
   Computes n!
   @param n a nonnegative integer
   @return n! = 1 * 2 * 3 * . . . * n
*/
int factorial(int n)
{  if (n == 0) return 1;
   int smaller_factorial = factorial(n - 1);
   int result = smaller_factoria * n;
   return result;
}
/**
   Generates all permutations of the characters in a string
   @param word a string
   @return a vector that is filled with all permutations 
   of the word
*/
vector<string> generate_permutations(string word)
{  vector<string> result;
   if (word.length() == 1) 
   {  result.push_back(word);
      return result;
   }

   for (int i = 0; i < word.length(); i++)
   {  string shorter_word = word.substr(0, i)
         + word.substr(i + 1, word.length() - i - 1);
      vector<string> shorter_permutations
         = generate_permutations(shorter_word);
      for (int j = 0; j < shorter_permutations.size(); j++)
      {  string longer_word = word[i] + shorter_permutations[j];
         result.push_back(longer_word);
      }   
   }
   return result;
}

int main()
{  cout << "Enter a string: ";
   string input;
   getline(cin, input);   
   cout << "There are " << factorial(input.length()) 
      << "permutations.\n";
   vector<string> v = generate_permutations(input);
   for (int i = 0; i < v.size(); i++)
      cout << v[i] << endl;
   return 0;
}

Ефективност на рекурсията

• Въпреки че рекурсията е мощен метод за сложни алгоритми, тя може да доведе до програми, които работят лошо.
• Ще анализираме въпроса кога рекурсията е полезна и когато тя е неефективна.
• Редица на Фибоначи се дефинира по следния начин:
  • f₁ = 1
  • f₂ = 1
  • f_n = f_n-1 + f_n-2
• Първите 10 члена на тази редица са:

  1, 1, 2, 3, 5, 8, 13, 21, 34, 55, . . .
  

• Лесно е да се напише рекурсивна функция, пресмятаща n-тото число на Фибоначи.

  int fib(int n)
  {  if (n <= 2) return 1;
     else return fib(n - 1) + fib(n - 2);
  }

• Тази функция работи вярно, но за не много големи n работи доста (изключително) бавно.
• Ще изпълним програмата (fibtest.cpp) с n между 30 и 50 за да видим ефекта.
• За откриване на проблема, ще вмъкнем трасиращ печат във функцията:

  int fib(int n)
  {  cout << "Entering fib: n = " << n << "\n";
     int f;
     if (n <= 2) f = 1;
     else f = fib(n - 1) + fib(n - 2);
     cout << "Exiting fib: n = " << n
        << " return value = " << f << "\n";
     return f;
  }

• Резултатът от функцията (fibtrace.cpp) показва защо изчислението отнема толкова време.

  Entering fib: n = 6
  Entering fib: n = 5
  Entering fib: n = 4
  Entering fib: n = 3
  Entering fib: n = 2
  Exiting fib: n = 2 return value = 1
  Entering fib: n = 1
  Exiting fib: n = 1 return value = 1
  Exiting fib: n = 3 return value = 2
  Entering fib: n = 2
  Exiting fib: n = 2 return value = 1
  Exiting fib: n = 4 return value = 3
  Entering fib: n = 3
  Entering fib: n = 2
  Exiting fib: n = 2 return value = 1
  Entering fib: n = 1
  Exiting fib: n = 1 return value = 1
  Exiting fib: n = 3 return value = 2
  Exiting fib: n = 5 return value = 5
  Entering fib: n = 4
  Entering fib: n = 3
  Entering fib: n = 2
  Exiting fib: n = 2 return value = 1
  Entering fib: n = 1
  Exiting fib: n = 1 return value = 1
  Exiting fib: n = 3 return value = 2
  Entering fib: n = 2
  Exiting fib: n = 2 return value = 1
  Exiting fib: n = 4 return value = 3
  Exiting fib: n = 6 return value = 8

• Дърво на извикванията:

  

• Тъй като fib(4) се вика два пъти, а fib(3) се вика три пъти, то много време се губи за многократни изчисления на една и съща стойност.

• Когато смятаме ръчно, просто събираме поседните две намерени стойности.
• Този метод може да се програмира с прост цикъл (fibloop.cpp).

  int fib(int n)
  {  if (n <= 2) return 1;
     int fold = 1;
     int fold2 = 1;
     int fnew;
     for (int i = 3; i <= n; i++)
     {  fnew = fold + fold2;
        fold2 = fold;
        fold = fnew;
     }
     return fnew;
  }

• Всяко рекурсивно решение може да се замени с итерационно (рекурсия с цикъл).
• Винаги ли итерационното решение е по-ефективно (по-бързо) от рекурсивното?
  
• Често двете решения са еднакво бързи (триъгълник, пермутации).
• Някои задачи се решават по-лесно с рекурсия откалкото с итерация.
• Решението на задачата за генериране на пермутации итеративно води до по-сложен на не по-бърз код.
• Често рекурсивни решения са по-лесни за разбиране и прилагане правилно, отколкото техните съответни итеративни решения.