const

class SomeClass {
public:
    bool empty();
};

class SomeClass {
public:
    bool empty(SomeClass* this); 
};

SomeClass sc;
if(sc.empty()) ... // для компилятора if(empty(&sc));

bool empty() const; // для компилятора bool empty(const SomeClass* this)

void f(); // версия для неконстантных объектов
void f() const; // версия для константных объектов

#include <stdlib.h>
using namespace std;
 
template <typename E>
class ArrayStack
{
    enum { DEFAULT_CAPACITY = 100 };
public:
    ArrayStack(int _capacity = DEFAULT_CAPACITY); // default stack capacity
    ~ArrayStack();
    int size() const;                             // number of items in the stack
    bool empty() const;                           // is the stack empty?
    const E& top() const throw(StackEmpty);       // get the top element
    void push(const E& e) throw(StackFull);       // push element 
    void pop() throw(StackEmpty);                 // pop element
 
private:
    E* S;            // array of stack elements
    int capacity;    // stack capacity
    int topIndex;    // index of the top of the stack
};

#include "Stack.h"
 
template <typename E> ArrayStack<E>::ArrayStack(int _capacity)
{
    this->S = new E(_capacity);
    this->capacity = _capacity;
    this->topIndex = -1;
} // constructor
 
template <typename E> int ArrayStack<E>::size() const 
{ return (this->topIndex + 1); } // get number of items in the stack
 
template <typename E> bool ArrayStack<E>::empty() //const
{ return (this->topIndex < 0); } // is the stack empty
 
template <typename E> const E& ArrayStack<E>::top() const throw(StackEmpty)
{
    if(empty()) throw StackEmpty("Top of empty stack");
    return (S[topIndex]);
} // get top value
 
template <typename E> void ArrayStack<E>::push(const E& e) throw(StackFull)
{
    if(size() == capacity) throw StackFull("Push to full stack");
    S[++topIndex] = e;
} // push tu stack
 
template <typename E> void ArrayStack<E>::pop() throw(StackEmpty)
{
    if(empty()) throw StackEmpty("Pop from empty stack");
    --topIndex;
}

void main()
{
    ArrayStack<int> S;
    S.push(7);
    S.push(15);
    cout << S.top() << endl; S.pop();
}

 ArrayStack<int> intS;
 ArrayStack<MyClass> myClassS;
 
...
 
 std::cout << intS.top(); // ok. top() возвращает int
 std::cout << myClassS.top(); // ошибка, если для MyClass не перегружен оператор << (top() возвращает ссылку на MyClass)