include <sceleton.h>
using namespace semetary;
while(corpse==die) {
return tamqn;
}
:D
//////////////////////////////////////////////////маитапа настрана//////////////////////////////////////////////
// $Id: skeleton.h,v 1.1 2009/07/05 10:43:44 sms Exp $
//
// A skeleton class declaration.
// References:
// 1. Effective C++. Second Edition.
// Scott Meyers.
// ISBN: 0-201-92488
//
// 2. The C++ Programming Language
// Bjarne Stroustrup.
// ISBN: 0-201-53992-6
//
#include <iostream> // No .h (Ref 1 Item 2)
class CCCCC: public BBBBB
{
public:
// Constructors.
// Initialisation List
// initialise all pointers (to zero) (Ref 1 Item 6, 12).
// list members in order declared in class (Ref 1 Item 13).
// Default Constructor
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// Used:
// CCCCC c1;
CCCCC ()
{};
// Copy constructor.
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// You will need to provide one if dynamic memory is used (Ref 1 Item 11).
// Used:
// CCCCC c1(c2);
// pass by value to function.
// return value from function
CCCCC (const CCCCC& rhs)
{
// Assign new dynamic memory and and copy over data (Ref 1 Item 11).
}
// Destructor
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// You will need to provide one if dynamic memory is used (Ref 1 Item 11).
// This should be virtual for Base classes.
virtual ~CCCCC ()
{
// Delete all dynamic memory (Ref 1 Item 6).
};
// Operators.
// Assignment operator.
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// You will need to provide one if dynamic memory is used (Ref 1 Item 11).
CCCC& operator= (const CCCCC& rhs)
{
// Don't copy to self (Ref 1, Item 17).
if (this != &rhs)
{
// Make sure that the base class assigns too (Ref 1 Item 16).
BBBBB::operator= (rhs);
// Delete existing memory from this and assign new
// (Ref 1 Item 6, 11).
// Copy data from (non-NULL) pointers into new memory.
// Assign all data members (Ref 1 Item 16).
}
// Returns *this (Ref 1 Item 15).
return *this;
}
// Address of operator (non const).
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// Used:
// CCCCC *c1 = &c2;
CCCC* operator& ()
{
return (this);
}
// Address of operator (const).
// The system will always provide one so make this private if you don't
// want it (Ref 1 Item 27). Remove the function if the default is ok.
// Used:
// const CCCCC *c1 = &c2;
const CCCC* operator& () const
{
return (this);
}
// The following operators can be declared (Ref 2 Section 7.2):
// + - * / % ^ & | ~ !
// = < > += -= *= /= %= ^= &=
// |= << >> >>= <<= == != <= >= &&
// || ++ -- ->* , -> [] () new delete
// NB: CCCC operator++ () is pre-increment.
// CCCC operator++ (int) is post-increment.
// There should be no public data members (Ref 1 Item 20).
private:
protected:
}
// I/O
// Declare these in header file.
// Define them in a source file
//
// Input
// This is never a class member (Ref 1 Item 19).
// Maybe a friend (Ref 1 Item 19).
// Maybe use an access function.
istream& istream::operator>> (istream& in, CCCCC ccc)
{
// (Ref 1 Item 19)
// Ensure (perhaps by using accesors):
// Delete any dynamically allocated data that will be overwritten
// Allocate new dynamically allocated data
// Read in data and set new values. eg:
// in >> newData;
// ccc.SetValue (newData);
return (*in);
}
// Output
// This is never a class member (Ref 1 Item 19).
// Maybe a friend (Ref 1 Item 19).
// Maybe use an access function.
ostream& ostream::operator<< (ostream& out, CCCCC ccc)
{
// Extract the data from the object. eg:
// out << ccc.printable();
return (*out);
}