Kartais universitetas priverčia išbandyti dalykus, kurie atrodo keistai, apie kuriuos anksčiau nežinojai, bet pamiršta pasakyti svarbiausią dalyką - koks jų praktinis pritaikymas.
Niekada negalvojau, jog įmanoma padaryti amžiną kompiliavimo ciklą. Dabar žinau - aš talentingas.
Norėčiau papasakoti, savo įspūdžius, kaip man pavyko susipažinti su c++ šablonais ir metaprogramavimu.

Metaprogramavimas - tai tokios programos rašymas, kuri generuoja kitą programą arba ja manipuliuoja. Programa, kuri kuriama arba kuria manipuliuojama, vadinama objektu ir pateikiama kaip duomenys. Programa, kuri atlieka manipuliacijas, vadinama metaprograma. Yra du meta programavimo būdai: homogeninis ir heterogeninis. Homogeninio programavimo metu objekto ir metaprogramos rašymui naudoja ta pati kalba, heterogeninio skirtingos.

Šį kartą aptarsiu tik homogeninį programavimo būdą. Pateiksiu pavyzdį c++ kalba, kurį man teko pasirašyti laboratorinio atlikimui ir paaiškinsiu kaip jis veikia. Bet prieš tai dar truputėlis teorijos:
Metaprogramoje nenaudojamos if-else sąlygos

if (salyga)
teiginys1;
else
teiginys;

jos yra keičiamos į:

template<bool C>
class _pavadinimas { };
class _pavadinimas<true> {
public:
static inline void funk()
{ teiginys1; } // true salyga
};
class _pavadinimas<false> {
public:
static inline void funk()
{ teiginys2; } // false sąlyga
};
// if-else sąlygos iškvietimas:
_pavadinimas<salyga>::funk();

switch-case taip pat yra keičiamas:

int i;
switch(i)
{
case reiksme1:
teiginys1;
break;
case reiksme2:
teiginys2;
break;
default:
teiginys3;
break;
}

į tokį kodą:

//Klasės aprašas
template<int I>
class _pavadinimas {
public:
static inline void funk()
{ teiginys3; }
};
class _pavadinimas<reiksme1> {
public:
static inline void funk()
{ teiginys1; }
};
class _pavadinimas<reiksme2> {
public:
static inline void funk()
{ teiginys2; }
};
// switch(i) sąlygos iškvietimas
_pavadinimas<I>::funk();

while ciklas

int i = N;
do {
teiginys;
} while (--i > 0);

keičiamas į:

// Klasės deklaracija
template<int I>
class _pavadinimas {
private:
enum { go = (I-1) != 0 };
public:
static inline void funk()
{
statement;
_pavadinimas<go ? (I-1) : 0>::funk();
// rekursijos kvietimas
}
};
class _pavadinimas<0> {
// ką daryti kai pasiekiama minimali reikšmė (nulis)? 
public:
static inline void f()
{ 
return 1;
}
};
// Ciklo kvietimas
_pavadinimas<N>::funk();

Beje, atkreipkite dėmesį, jog tai atvirkščias do-while ciklas, sukamas nuo didžiausios reikšmės iki mažiausios.

Tiek turėtų užtekti, kad galėtume spręsti pagrindinius uždavinius, nors prie pilnos kompanijos čia dar trūksta for ciklo.
Laboratorinio užduotis:
Apibendrinkite etaloninę funkciją sinh(x) pagal 2 nepriklausomus parametrus: duomenų tipą {float, double} ir eilutės narių skaičių {2..8}. Naudoti C++ templates.

float _sinh_2 (float x) {
return x * (1 + x*x/6);
}
 
double _sinh_3 (double x) {
return x * (1 + x*x/6) * (1 + x*x/20));
}
 
float _sinh_4 (float x) {
return x * (1 + x*x/6 * (1 + x*x/20 * (1 + x*x/42)));
}

Pagal duomenų tipą aš šį kartą neapibendrinsiu, tik pagal eilutės narių skaičių. Tiesą pasakius, užduotis gana kvaila, nes labai stipriai nukenčia tikslumas.

Pirmiausiai pasirašysime paprastą apibendrintą c++ funkciją, o po to ją versime į šabloną:

double sinh2(double x, int j)
{
double val = 1;
int k=1;
do
{k++;
val = 1 + x *x/((k-2+k)*(k-1+k))*val;
}while(k!=j);
return x * val;
}

Jeigu atidžiai pažvelgsite į kodą iš karto pastebėsite, kaip pagaminti amžiną ciklą. Tiems, kurie neatkreipė dėmesio pašnibždėsiu, kai j<2. Suprasite, kodėl nedėjau if-else sąlygos, kai pažvelgsite truputį aukščiau, kur aš aiškinau kaip ją paversti į šabloną.

Prieš tęsiant, reiktų pasakyti dar keletą dalykų. Mokindamasis kurti c++ šablonus pastebėjau, jog kaip parametrus visuomet paduoda tik sveikus skaičius, o pagal užduotį man reikia paduoti float. Norėdamas išspręsti savo užduotį nagrinėjau kitą kodą, kuriame realizuota sin(), tenai reikšmę x keisdavo pagal formule x=I*2*M_PI/N, tiesa, aš nesu tikras ar mano reikalinga pi, vis tik sinh() yra hiperbolis sinusas.

#include "stdafx.h"
#include <iostream>
#define _USE_MATH_DEFINES
// vėliau naudojam PI konstantą
#include <math.h>
using namespace std;
//---------------------------------------------------------------------------
template<int N, int I, int J, int K>
class SineSeries
{
 public:
  enum { go = (K != J) };
 
  static inline float accumulate()
  {
    return 1+(I*2*M_PI/N)*(I*2*M_PI/N)/((K-2+K)*(K-1+K)) *
    SineSeries<N*go,I*go,J*go,(K+1)*go>::accumulate();
  }
};

Pagrindinė funkcija, atlieka skaičiavimą ir iteraciją į save.

template<>
class SineSeries<0,0,0,0> 
{
 public:
  static inline float accumulate()
  { 
    return 1; 
  }
};

kai while ciklas pasiekia nulinę reikšmę iškviečiama šita funkcija.

template<int N, int I, int max>
class Sine
{
 public:
  static inline float sinh()
  {
    return (I*2*M_PI/N) * SineSeries<N,I,max,2>::accumulate();
  }
};

grąžinimas galutinis rezultatas.

void main()
{
   Sine <10, 20, 2> obj;
    cout << "rezultatai:" << obj.sinh(); 
}

Pagrindinė funkcija, kuri inicijuoja naudojimąsi mano sukurtu šablonu. Trečias skaičius negali būti mažesnis už du, nes turėsite amžiną ciklą ant kompiliavimo.

Tai tokia mano pažintis su šablonais ir metaprogramavimu. Pagrindinis privalumas - skaičiavimai atliekami žymiai greičiau. Tačiau darydamas šį laboratorinį susiduriau net su keliais trūkumas: 1) iteracijos kodas man niekada nebuvo aiškus; 2) daug kodo, su paprastu ciklu tik 10 eilučių.

Tikiuosi kam nors padės šis straipsnelis, nes informacijos nėra daug šita tema, o kartais reikia.

Dėkoju visiems, kurie padėjo pasidaryti man laboratorinį darbą.

Dar informacijos galima rasti čia:
Atviras Kodas Wiki

Panašūs straipsniai

• Įdomesnis ir linksmesnis programavimas su C# 3.0 (12)
• while vs. for (14)
• Side-Scroller tipo žaidimo kūrimas (1)
• Process vs WMI (0)
• Paleidinėjam programas iš savo kodo. (0)

Žymėti: kaip.tik.ten | del.icio.us | topix.lt | žynios.lt