---------------
class X {
private:                  // reprezentacja (implementacja) jest prywatna
    int m;
public:                   // interfejs uytkownika jest publiczny
    X(int i =0) :m{i} { } // konstruktor (inicjuje skadow m)

    int mf(int i)         // funkcja skadowa
    {
        int old = m;
        m=i;              // ustawienie nowej wartoci
        return old;       // zwraca star warto
    }
};

X var {7}; // zmienna typu X, zainicjowana wartoci 7

int user(X var, X* ptr)
{
    int x = var.mf(7);    // dostp przy uyciu operatora . (kropki)
    int y = ptr->mf(9);   // dostp przy uyciu operatora -> (strzaki)
    int z = var.m;        // bd: brak dostpu do skadowej prywatnej
}
---------------
struct Date { // reprezentacja
    int d, m, y;
};

void init_date(Date& d, int, int, int); // inicjuje d
void add_year(Date& d, int n);          // dodaje n lat do d
void add_month(Date& d, int n);         // dodaje n miesicy do d
void add_day(Date& d, int n);           // dodaje n dni do d
---------------
struct Date {
    int d, m, y;

    void init(int dd, int mm, int yy); // inicjuje
    void add_year(int n);              // dodaje n lat
    void add_month(int n);             // dodaje n miesicy
    void add_day(int n);               // dodaje n dni
};
---------------
Date my_birthday;

void f()
{
    Date today;

    today.init(16,10,1996);
    my_birthday.init(30,12,1950);

    Date tomorrow = today;
    tomorrow.add_day(1);
    //...
}
---------------
void Date::init(int dd, int mm, int yy)
{
    d=dd;
    m = mm;
    y = yy;
}
---------------
Date d1 = my_birthday; // inicjacja przez kopi
Date d2 {my_birthday}; // inicjacja przez kopi
---------------
void f(Date& d)
{
    d = my_birthday;
}
---------------
class Date {
    int d, m, y;
public:
    void init(int dd, int mm, int yy); // inicjuje

    void add_year(int n);              // dodaje n lat
    void add_month(int n);             // dodaje n miesicy
    void add_day(int n);               // dodaje n dni
};
---------------
void Date::add_year(int n)
{
    y+=n;
}
---------------
void timewarp(Date& d)
{
    d.y -= 200; // bd: Date::y to skadowa prywatna
}
---------------
Date dx;
dx.m = 3;           // bd: m jest prywatna
dx.init(25,3,2011); // OK
---------------
class X { ... };
---------------
struct S { /*...*/ };
---------------
class S { public: /*...*/ };
---------------
class Date1 {
    int d, m, y;          // prywatne domylnie
public:
    Date1(int dd, int mm, int yy);
    void add_year(int n); // dodaje n lat
};
---------------
struct Date2 {
private:
    int d, m, y;
public:
    Date2(int dd, int mm, int yy);
    void add_year(int n); // dodaje n lat
};
---------------
class Date3 {
public:
    Date3(int dd, int mm, int yy);
    void add_year(int n); // dodaje n lat
private:
    int d, m, y;
};
---------------
class Date4 {
public:
    Date4(int dd, int mm, int yy);
private:
    int d, m, y;
public:
    void add_year(int n); // dodaje n lat
};
---------------
class Date {
    int d, m, y;
public:
    Date(int dd, int mm, int yy); // konstruktor
    //...
};
---------------
Date today = Date(23,6,1983);
Date xmas(25,12,1990);   // forma skrcona
Date my_bir thday;       // bd: brak inicjatora
Date release1_0(10,12);  // bd: brak trzeciego argumentu
---------------
Date today = Date {23,6,1983};
Date xmas{25,12,1990};   // forma skrcona
Date release1_0 {10,12}; // bd: brak trzeciego argumentu
---------------
class Date {
    int d, m, y;
public:
    //...

    Date(int, int, int); // dzie, miesic, rok
    Date(int, int);      // dzie, miesic, aktualny rok
    Date(int);           // dzie, aktualny miesic i rok
    Date();              // domylna data: dzi
    Date(const char*);   // data w reprezentacji acuchowej
};
---------------
Date today {4};          // 4, today.m, today.y
Date july4 {"lipiec 4, 1983"};
Date guy {5,11};         // 5, listopad, today.y
Date now;                // domylna inicjacja dzisiejsz dat
Date start {};           // domylna inicjacja dzisiejsz dat
---------------
class Date {
    int d, m, y;
public:
    Date(int dd =0, int mm =0, int yy =0);
    //...
};

Date::Date(int dd, int mm, int yy)
{
    d = dd ? dd : today.d;
    m = mm ? mm : today.m;
    y = yy ? yy : today.y;
    // sprawdzenie, czy data jest poprawna
}
---------------
class Date {
    int d, m, y;
public:
    Date(int dd =today.d, int mm =today.m, int yy =today.y);
    //...
};

Date::Date(int dd, int mm, int yy)
{
    // sprawdzenie, czy data jest poprawna
}
---------------
complex<double> d {1}; // d=={1,0} (5.6.2)
---------------
void my_fct(Date d);

void f()
{
    Date d {15}; // moliwe: d staje si {15,today.m,today.y}
    //...
    my_fct(15);  // niejasne
    d = 15;      // niejasne
    //...
}
---------------
class Date {
    int d, m, y;
public:
    explicit Date(int dd =0, int mm =0, int yy =0);
    //...
};

Date d1 {15};         // OK: konwersja jawna
Date d2 = Date{15};   // OK: jawne
Date d3 = {15};       // bd: inicjacja = nie moe dokonywa niejawnych konwersji
Date d4 = 15;         // bd: inicjacja = nie moe dokonywa niejawnych konwersji

void f()
{
    my_fct(15);       // bd: przekazanie argumentu nie moe dokonywa niejawnych konwersji
    my_fct({15});     // bd: przekazanie argumentu nie moe dokonywa niejawnych konwersji
    my_fct(Date{15}); // OK: jawne
    //...
}
---------------
class Date {
    int d, m, y;
public:
    explicit Date(int dd);
    //...
};

Date::Date(int dd) { /*...*/ }          // OK
explicit Date::Date(int dd) { /*...*/ } // bd
---------------
struct X {
    explicit X();
    explicit X(int,int);
};

X x1 = {};          // bd: niejawne
X x2 = {1,2};       // bd: niejawne

X x3 {};            // OK: jawne
X x4 {1,2};         // OK: jawne

int f(X);

int i1 = f({});     // bd: niejawne
int i2 = f({1,2});  // bd: niejawne

int i3 = f(X{});    // OK: jawne
int i4 = f(X{1,2}); // OK: jawne
---------------
class Date {
    int d, m, y;
public:
    Date(int, int, int); // dzie, miesic, rok
    Date(int, int);      // dzie, miesic, aktualny rok
    Date(int);           // dzie, aktualny miesic i rok
    Date();              // domylna data: dzi
    Date(const char*);   // data w reprezentacji acuchowej
    //...
};
---------------
class Date {
    int d {today.d};
    int m {today.m};
    int y {today.y};
public:
    Date(int, int, int); // dzie, miesic, rok
    Date(int, int);      // dzie, miesic, aktualny rok
    Date(int);           // dzie, aktualny miesic i rok
    Date();              // domylna data: dzi
    Date(const char*);   // data w reprezentacji acuchowej
    //...
---------------
Date::Date(int dd)
:d{dd}
{
    // sprawdzenie, czy data jest poprawna
}
---------------
Date::Date(int dd)
    :d{dd}, m{today.m}, y{today.y}
{
    // sprawdzenie, czy data jest poprawna
}
---------------
class Date {
public:
    void add_month(int n) { m+=n; } // zwiksza warto m daty
    //...
private:
    int d, m, y;
};
---------------
class Date {
public:
    void add_month(int n) { m+=n; } // zwiksza warto m daty
    //...
private:
    int d, m, y;
};

inline void Date::add_month(int n) // dodaje n miesicy
{
    m+=n; // zwiksza warto m daty
}
---------------
class Date {
    int d, m, y;
public:
    int day() const { return d; }
    int month() const { return m; }
    int year() const;

    void add_year(int n); // dodaje n lat
    //...
};
---------------
int Date::year() const
{
    return ++y; // bd: prba zmiany wartoci skadowej w funkcji const
}
---------------
int Date::year() // bd: brak const w typie funkcji skadowej
{
    return y;
}
---------------
void f(Date& d, const Date& cd)
{
    int i = d.year();  // OK
    d.add_year(1);     // OK

    int j = cd.year(); // OK
    cd.add_year(1);    // bd: nie mona zmieni wartoci const Date
}
---------------
class Date {
public:
    //...
    string string_rep() const;  // reprezentacja acuchowa
private:
    bool cache_valid;
    string cache;
    void compute_cache_value(); // napenia bufor
    //...
};
---------------
class Date {
public:
    //...
    string string_rep() const;        // reprezentacja acuchowa
private:
    mutable bool cache_valid;
    mutable string cache;
    void compute_cache_value() const; // napenia (modyfikowalny) bufor
    //...
};
---------------
string Date::string_rep() const
{
    if (!cache_valid) {
        compute_cache_value();
        cache_valid = true;
    }
    return cache;
}
---------------
void f(Date d, const Date cd)
{
    string s1 = d.string_rep();
    string s2 = cd.string_rep(); // OK!
    //...
}
---------------
struct cache {
    bool valid;
    string rep;
};

class Date {
public:
    //...
    string string_rep() const;        // reprezentacja acuchowa
private:
    cache* c;                         // inicjacja w konstruktorze
    void compute_cache_value() const; // wstawia to, co wskazuje bufor
    //...
};

string Date::string_rep() const
{
    if (!c->valid) {
        compute_cache_value();
        c->valid = true;
    }
    return c->rep;
}
---------------
void f(Date& d)
{
    //...
    d.add_day(1).add_month(1).add_year(1);
    //...
}
---------------
class Date {
    //...
    Date& add_year(int n);  // dodaje n lat
    Date& add_month(int n); // dodaje n miesicy
    Date& add_day(int n);   // dodaje n dni
};
---------------
Date& Date::add_year(int n)
{
    if (d==29 && m==2 && !leapyear(y+n)) { // uwaga na 29 lutego
        d=1;
        m=3;
    }
    y+=n;
    return* this;
}
---------------
Date& Date::add_year(int n)
{
    if (this->d==29 && this->m==2 && !leapyear(this->y+n)) {
        this->d = 1;
        this->m = 3;
    }
    this->y += n;
    return* this;
}
---------------
struct Link {
    Link* pre;
    Link* suc;
    int data;

    Link* insert(int x) // wstawia x przed this
    {
        return pre = new Link{pre,this,x};
    }

    void remove()       // kasuje this
    {
        if (pre) pre->suc = suc;
        if (suc) suc->pre = pre;
        delete this;
    }

    //...
};
---------------
struct X {
    void f();
    int m;
};

void user(X x, X* px)
{
    m=1;       // bd: nie ma m w zakresie
    x.m = 1;   // OK
    x->m = 1;  // bd: x nie jest wskanikiem
    px->m = 1; // OK
    px.m = 1;  // bd: px jest wskanikiem
}
---------------
void X::f()
{
    m=1; // OK: this->m = 1; (16.2.10)
}
---------------
struct X {
    int f() { return m; } // w porzdku, zwraca m tego obiektu X
    int m;
};
---------------
struct S {
    int m;
    int f();
    static int sm;
};

int X::f() { return m; }  // f klasy X
int X::sm {7};            // statyczna skadowa sm klasy X (16.2.12)
int (S::*) pmf() {&S::f}; // skadowa f klasy X
---------------
class Date {
    int d, m, y;
    static Date default_date;
public:
    Date(int dd =0, int mm =0, int yy =0);
    //...
    static void set_default(int dd, int mm, int yy); // ustawia default_date na Date(dd,mm,yy)
};
---------------
Date::Date(int dd, int mm, int yy)
{
    d = dd ? dd : default_date.d;
    m = mm ? mm : default_date.m;
    y = yy ? yy : default_date.y;
    //... sprawdzenie, czy data jest poprawna...
}
---------------
void f()
{
    Date::set_default(4,5,1945); // wywouje statyczn skadow set_default() klasy Date
}
---------------
Date Date::default_date {16,12,1770};       // definicja skadowej Date::default_date

void Date::set_default(int d, int m, int y) // definicja skadowej Date::set_default
{
    default_date = {d,m,y};                 // przypisanie nowej wartoci do default_date
}
---------------
Date copy_of_default_date = Date{};

void f(Date);

void g()
{
    f(Date{});
}
---------------
void f1(Date);

void f2(Date);
void f2(int);

void g()
{
    f1({});     // OK: rwnowane z f1(Date{})
    f2({}):     // bd niejednoznacznoci: f2(int) czy f2(Date)?
    f2(Date{}); // OK
---------------
template<typename T>
class Tree {
    using value_type = T;              // alias skadowy
    enum Policy { rb, splay, treeps }; // wyliczenie skadowe
    class Node {                       // klasa skadowa
        Node* right;
        Node* left;
        value_type value;
    public:
        void f(Tree*);
    };
    Node* top;
public:
    void g(const T&);
    //...
};
---------------
template<typename T>
void Tree::Node::f(Tree* p)
{
    top = right;                // bd: nie okrelono adnego obiektu typu Tree
    p->top = right;             // OK
    value_type v = left->value; // OK: value_type nie jest zwizana z obiektem
}
---------------
template<typename T>
void Tree::g(Tree::Node* p)
{
    value_type val = right->value;  // bd: nie ma obiektu typu Tree::Node
    value_type v = p->right->value; // bd: Node::right jest skadow prywatn
    p->f(this);                     // OK
}
---------------
namespace Chrono {

    enum class Month { sty=1, lut, mar, kwi, maj, cze, lip, sie, wrz, pa, lis, gru };

    class Date {
    public: // interfejs publiczny:
        class Bad_date { }; // klasa wyjtkw

    explicit Date(int dd ={}, Month mm ={}, int yy ={}); // {} oznacza "wybierz domylne"
    // niemodyfikujce funkcje do badania obiektw klasy Date:
        int day() const;
        Month month() const;
        int year() const;

        string string_rep() const;             // reprezentacja acuchowa
        void char_rep(char s[], in max) const; // reprezentacja w postaci acucha w stylu C

    // modyfikujce funkcje do zmieniania dat:
        Date& add_year(int n);                 // dodaje n lat
        Date& add_month(int n);                // dodaje n miesicy
        Date& add_day(int n);                  // dodaje n dni
    private:
        bool is_valid();                       // sprawdza, czy ten obiekt klasy Date reprezentuje dat
        int d, m, y;                           // reprezentacja
    };

    bool is_date(int d, Month m, int y);       // true dla poprawnej daty
    bool is_leapyear(int y);                   // true, jeli y jest rokiem przestpnym

    bool operator==(const Date& a, const Date& b);
    bool operator!=(const Date& a, const Date& b);

    const Date& default_date();                // domylna data

    ostream& operator<<(ostream& os, const Date& d); // drukuje d w os
    istream& operator>>(istream& is, Date& d);       // wczytuje obiekt klasy Date z is do d
} // Chrono
---------------
void f(Date& d)
{
    Date lvb_day {16,Month::gru,d.year()};

    if (d.day()==29 && d.month()==Month::lut) {
        //...
    }

    if (midnight()) d.add_day(1);

    cout << "Dzie po:" << d+1 << '\n';

    Date dd; // inicjowany domyln dat
    cin>>dd;
    if (dd==d) cout << "Hura!\n";
}
---------------
struct Date {
    int day, month, year;
};
---------------
const Date& Chrono::default_date();
---------------
Date::Date(int dd, Month mm, int yy)
    :d{dd}, m{mm}, y{yy}
{
    if (y == 0) y = default_date().year();
    if (m == Month{}) m = default_date().month();
    if (d == 0) d = default_date().day();
    if (!is_valid()) throw Bad_date();
}
---------------
void fill(vector<Date>& aa)
{
    while (cin) {
        Date d;
        try{
            cin >> d;
        }
        catch (Date::Bad_date) {
            //... obsuga bdw...
            continue;
        }
        aa.push_back(d); // zobacz 4.4.2
    }
}
---------------
bool Date::is_valid()
{
    return is_date(d,m,y);
}
---------------
inline int Date::day() const
{
    return d;
}

Date& Date::add_month(int n)
{
    if (n==0) return *this;

    if (n>0) {
        int delta_y = n/12;                // liczba penych lat
        int mm = static_cast<int>(m)+n%12; // liczba pozostaych miesicy
        if (12 < mm) {                     // uwaga: gru reprezentuje liczba 12
            ++delta_y;
            mm -= 12;
        }

        //... Obsuga przypadkw, w ktrych miesic mm nie ma dnia d...

        y += delta_y;
        m = static_cast<Month>(mm);
        return *this;
    }

    //... Obsuga ujemnego n...

    return* this;
}
---------------
int diff(Date a, Date b); // liczba dni w przedziale <a,b) lub <b,a)

bool is_leapyear(int y);
bool is_date(int d, Month m, int y);

const Date& default_date();
Date next_weekday(Date d);
Date next_saturday(Date d);
---------------
#include "Date.h"
---------------
namespace Chrono { // narzdzia do pracy z czasem

    class Date { /*...*/ };

    int diff(Date a, Date b);
    bool is_leapyear(int y);
    bool is_date(int d, Month m, int y);
    const Date& default_date();
    Date next_weekday(Date d);
    Date next_saturday(Date d);
    //...
}
---------------
bool Chrono::is_date(int d, Month m, int y)
{
    int ndays;

    switch (m) {
    case Month::lut:
        ndays = 28+is_leapyear(y);
        break;
    case Month::kwi: case Month::cze: case Month::wrz: case Month::lis:
        ndays = 30;
        break;
    case Month::sty: case Month::mar: case Month::maj: case Month::lip:
    case Month::sie: case Month::pa: case Month::gru:
        ndays = 31;
        break;
    default:
        return false;
    }

    return 1<=d && d<=ndays;
}
---------------
const Date& Chrono::default_date()
{
    static Date d {1,Month::sty,1970};
    return d;
}
---------------
inline bool operator==(Date a, Date b) // rwno
{
    return a.day()==b.day() && a.month()==b.month() && a.year()==b.year();
}
---------------
bool operator!=(Date, Date); // nierwno
bool operator<(Date, Date);  // mniejszo
bool operator>(Date, Date);  // wikszo
//...

Date& operator++(Date& d) { return d.add_day(1); }         // dodaje jeden dzie
Date& operator--(Date& d) { return d.add_day(-1); }        // odejmuje jeden dzie

Date& operator+=(Date& d, int n) { return d.add_day(n); }  // dodaje n dni
Date& operator-=(Date& d, int n) { return d.add_day(-n); } // odejmuje n dni

Date operator+(Date d, int n) { return d+=n; }             // dodaje n dni
Date operator-(Date d, int n) { return d+=n; }             // odejmuje n dni

ostream& operator<<(ostream&, Date d);                     // wysya d na wyjcie
istream& operator>>(istream&, Date& d);                    // wczytuje do d
---------------
class Date_and_time {
private:
    Date d;
    Time t;
public:
    Date_and_time(Date d, Time t);
    Date_and_time(int d, Date::Month m, int y, Time t);
    //...
};
---------------
Month do_something(Date d);
---------------
int do_something(int d);