Obvyklá stavba při tvorbě tříd

Když tvořím třídu, deklaraci píšu do souboru s příponou h, do cpp píšu definici (metody).

class Trida
{
private:       // zde vidi jen objekty tridy
int i;    
protected:     // zde vidi jen objekty teto a zdedenych trid
float f:
public: 
Trida();       // implicitni konstruktor

~Trida(); //destruktor
void nacti();  // deklarace fce - definice radeji na konci programu
};

Podmíněný překlad

Direktivy preprocesoru umožňují předepsat, že v závislosti na určitých podmínkách chceme či nechceme překládat určité úseky zdrojového textu.
V následujícím syntaktickém popisu označuje úsek-programu několik řádků Každá direktiva musí být stejně jako ostatní direktivy preprocesoru na samostatném řádku.

Syntaxe:

#if konstantní_výraz nový_řádek 
#ifdef identifikátor nový_řádek 
#ifndef identifikátor nový_řádek 
#elif konstantní_výraz nový_řádek 
#else nový_řádek 
#endif nový_řádek

Podmíněně překládaný úsek programu začíná direktivou #if (nebo #ifdef nebo #ifndef, které slouží jako zkratky pro #if s určitým podmíněným výrazem). Pak může následovat několik úseků začínajících direktivou #elif. Po nich může přijít jeden úsek začínající direktivou #else. Úsek programu s podmíněnou kompilací musí končit direktivou #endif.

Konstantní výrazy mohou obsahovat celočíselné literály, identifikátory definované v direktivě #define a případně operátor defined. V C++ mohou obsahovat i konstanty deklarované pomocí modifikátoru const a inicializované konstantním výrazem.

#if konstantní_výraz_l
  úsek_programu_l 
#elif konstantní_výraz_2 
  úsek_programu_2 
#else usek_programu_3
#endif

Preprocesor vyhodnotí konstantní_výraz_1. Je-li jeho hodnota true (nenulová), přeloží úsek_programu_1. Úseky programu za direktivami #elif a #else ze zdrojového textu vypustí a přejde na zdrojový text za direktivu #endif. Je-li hodnota konstantního_výrazu_1 rovna false, resp. 0, odstraní preprocesor úsek_programu_1 a vyhodnotí konstantní_výraz_2 za #elif. Je-li jeho hodnota nenulová, přeloží úsek_programu_2, odstraní úsek_programu_3 pak přejde za direktivu #endif. Je-li i hodnota konstantního_výrazu_2 rovna false, odstraní se ze zdrojového textu také úsek_programu_2 přeloží úsek_programu_3.

• Libovolný z úseků programu může opět obsahovat direktivy #if , #endif. Přitom ovšem musíme dát pozor na správné párování #if a #endif.
• Preprocesor odstraní kromě nepřekládaného zdrojového textu samozřejmě také tyto direktivy.

#ifndef _muj_h 
  #define _muj_h 
   
  int Maximum(int a, int b, int c); 
  int Minimum(int a, int b, int c); 
#endif

struct {
        int vyska; 
        float vaha;
       } pavel, honza, karel;

struct miry { 
             int vyska;
             float vaha;
            } pavel, honza, karel;

struct miry jan, martin; // definice proměnných

       miry jan, martin; // chyba

typedef struct {
                int vyska;
                float vaha;
               } MIRY;

MIRY pavel, honza, karel;

typedef struct polozka {
                        int hodnota;
                        struct položka *dalsi;
                       } POLOZKA;

pavel.vyska = 186;

MIRY lide[100]; 
lide[50].vyska = 176;

typedef struct { 
                int pole[10];
               } STR_POLE;

STR_POLE x; 
x.pole[1] = 5;

MIRY *clovek; 
clovek = (MIRY*) malloc(sizeof(MIRY));

(*clovek).vaha = 70.4; // nebo jednodušeji  
  clovek->vaha = 70.4; 

MIRY a = {190, 84.3};

typedef union {
               char c;
               int i;
               float f;
              } TEST;

typedef enum {
              MODRA, CERVENA, ZELENA, ZLUTA
             } BARVY;

BARVY x = MODRA;

typedef enum {
              MODRA = 5, CERVENA = 8, ZELENA, ZLUTA = 15      
             } BARVY;  // ZELENA bude mít číslo 9

int a = 0, b = 8;
a = 5 * b; <- R
L -> a = b; <- L
Chyba -> 5 * b = a;

E1 ? E2 : E3

a + b + c

(a + b) + c

a = b = 3.1;

a = (b = 3.1);

f() + g() + h()

(f() + g()) + h()

// scitani dvou zlomku(struktur s prvky cit a jmen)
  Zlomek operator+(Zlomek zl1, Zlomek zl2)
  {
    Zlomek soucet;
    soucet.cit=((zl1.cit*zl2.jmen)+(zl1.jmen*zl2.cit));
    soucet.jmen=zl1.jmen*zl2.jmen;
    return soucet;
  }
  

// Soubor COMPLEX.H 
 class complex 
  {
   public:
    complex(double r = 0, double i = 0);   //Konstruktor
    complex operator+(complex& c);         //Aritmetické operátory
    complex operator*(complex& c); 
    complex operátor-(complex& c); 
    complex operator/(complex& c); 
    
    double Re();                           //Reálná a imaginární část
    double Im(); 
    double abs();                          //Absolutní hodnota
   private: double re, im;                 //Datové složky
  };