Russian Qt Forum

C++ (Qt)
#ifndef GAME_H
#define GAME_H
 
#include <QJsonObject>
#include <QList>
 
#include "character.h"
#include "level.h"
 
//! [0]
class Game
{
public:
    Game();
 
    enum SaveFormat {
        Json, Binary
    };
 
    const Character &player() const;
    const QList<Level> &levels() const;
 
    void newGame();
    bool loadGame(SaveFormat saveFormat);
    bool saveGame(SaveFormat saveFormat) const;
 
    void read(const QJsonObject &json);
    void write(QJsonObject &json) const;
private:
    Character mPlayer;
    QList<Level> mLevels;
};
//! [0]
 
#endif // GAME_H
 

C++ (Qt)
#ifndef CHARACTER_H
#define CHARACTER_H
 
#include <QJsonObject>
#include <QString>
 
//! [0]
class Character
{
public:
    enum ClassType {
        Warrior, Mage, Archer
    };
 
    Character();
    Character(const QString &name, int level, ClassType classType);
 
    QString name() const;
    void setName(const QString &name);
 
    int level() const;
    void setLevel(int level);
 
    ClassType classType() const;
    void setClassType(ClassType classType);
 
    void read(const QJsonObject &json);
    void write(QJsonObject &json) const;
private:
    QString mName;
    int mLevel;
    ClassType mClassType;
};
//! [0]
 
#endif // CHARACTER_H
 

C++ (Qt)
#ifndef LEVEL_H
#define LEVEL_H
 
#include <QJsonObject>
#include <QList>
 
#include "character.h"
 
//! [0]
class Level
{
public:
    Level();
 
    const QList<Character> &npcs() const;
    void setNpcs(const QList<Character> &npcs);
 
    void read(const QJsonObject &json);
    void write(QJsonObject &json) const;
private:
    QList<Character> mNpcs;
};
//! [0]
 
#endif // LEVEL_H
 

C++ (Qt)
#include <QCoreApplication>
 
#include "game.h"
//! [0]
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    Game game;
    game.newGame();
    // Game is played; changes are made...
//! [0]
//! [1]
    if (!game.saveGame(Game::Json))
        return 1;
 
    if (!game.saveGame(Game::Binary))
        return 1;
 
    Game fromJsonGame;
    if (!fromJsonGame.loadGame(Game::Json))
        return 1;
 
    Game fromBinaryGame;
    if (!fromBinaryGame.loadGame(Game::Binary))
        return 1;
 
    return 0;
}
//! [1]
 

C++ (Qt)
void Game::newGame() {
    mPlayer = Character();
    mPlayer.setName(QStringLiteral("Hero"));
    mPlayer.setClassType(Character::Archer);
    mPlayer.setLevel(15);
 
    mLevels.clear();
 
    Level village;
    QList<Character> villageNpcs;
    villageNpcs.append(Character(QStringLiteral("Barry the Blacksmith"), 10, Character::Warrior));
    villageNpcs.append(Character(QStringLiteral("Terry the Trader"), 10, Character::Warrior));
    village.setNpcs(villageNpcs);
    mLevels.append(village);
 
    Level dungeon;
    QList<Character> dungeonNpcs;
    dungeonNpcs.append(Character(QStringLiteral("Eric the Evil"), 20, Character::Mage));
    dungeonNpcs.append(Character(QStringLiteral("Eric's Sidekick #1"), 5, Character::Warrior));
    dungeonNpcs.append(Character(QStringLiteral("Eric's Sidekick #2"), 5, Character::Warrior));
    dungeon.setNpcs(dungeonNpcs);
    mLevels.append(dungeon);
}
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "rational.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    // Перемножаем дроби и выводим результат на экран
    Rational a(2, 3), b(1, 2), c(3, 4), product;
    product = a * b * c;
    cout << "product = " << product.numerator() << "/" << product.denominator() << endl;
    cout.flush();
 
    // Складываем дроби и выводим результат на экран
    Rational x(47, 48), y(15, 16), sum;
    sum = x + y;
    cout << "sum = " << sum.numerator() << "/" << sum.denominator() << endl;
    cout.flush();
 
    // Вычитаем дроби и выводим результат на экран
    Rational m(47, 48), n(15, 16), sub;
    sub = m - n;
    cout << "sub = " << sub.numerator() << "/" << sub.denominator() << endl;
    cout.flush();
 
    return app.exec();
}
 

C++ (Qt)
#ifndef RATIONAL_H
#define RATIONAL_H
 
class Rational
{
public:
    Rational(int numerator = 0, int denominator = 1);
 
    int numerator() const;
    void setNumerator(const int numerator);
 
    int denominator() const;
    void setDenominator(const int denominator);
 
    friend const Rational operator*(const Rational& lhs, const Rational& rhs);
    friend const Rational operator+(const Rational& lhs, const Rational& rhs);
    friend const Rational operator-(const Rational& lhs, const Rational& rhs);
 
private:
    int mNumerator;
    int mDenominator;
};
 
#endif // RATIONAL_H
 

C++ (Qt)
#include "rational.h"
 
Rational::Rational(int numerator, int denominator) :
    mNumerator(numerator),
    mDenominator(denominator)
{
}
 
int Rational::numerator() const
{
    return mNumerator;
}
 
void Rational::setNumerator(const int numerator)
{
    mNumerator = numerator;
}
 
int Rational::denominator() const
{
    return mDenominator;
}
 
void Rational::setDenominator(const int denominator)
{
    mDenominator = denominator;
}
 
const Rational operator*(const Rational &lhs, const Rational &rhs)
{
    return Rational(lhs.mNumerator * rhs.mNumerator,
                    lhs.mDenominator * rhs.mDenominator);
}
 
const Rational operator+(const Rational &lhs, const Rational &rhs)
{
    Rational result;
 
    // Общий знаменатель
    int commonDenominator = lhs.denominator() * rhs.denominator();
 
    // Числитель
    int a = lhs.numerator() * rhs.denominator();
    int b = rhs.numerator() * lhs.denominator();
    result.setNumerator(a + b);
 
    // Знаменатель
    result.setDenominator(commonDenominator);
 
    return result;
}
 
const Rational operator-(const Rational &lhs, const Rational &rhs)
{
    Rational result;
 
    // Общий знаменатель
    int commonDenominator = lhs.denominator() * rhs.denominator();
 
    // Числитель
    int a = lhs.numerator() * rhs.denominator();
    int b = rhs.numerator() * lhs.denominator();
    result.setNumerator(a - b);
 
    // Знаменатель
    result.setDenominator(commonDenominator);
 
    return result;
}
 

C++ (Qt)
class Rational {
public:
 friend std::ofstream & operator << ( std::ofstream & strm, const Rational & r );
 ...
}

C++ (Qt)
class Rational {
public:
 template <class stream>
 friend stream & operator << ( stream & strm, const Rational & r );
 ...
}

C++ (Qt)
#if !defined(QT_NO_DATASTREAM) || (defined(QT_BOOTSTRAPPED) && !defined(QT_BUILD_QMAKE))
Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QString &);
Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QString &);
#endif
 

C++ (Qt)
class Bar
{
public:
	Bar(int ii = 0) : i(ii) { }
	int i;
};
 
QTextStream& operator<<(QTextStream& stream, const Bar& bar)
{
	stream << QString::number(bar.i);
	return stream;
}
int main(int argc, char *argv[])
{
	Bar b1(1);
 
	QString s;
	QTextStream out(&s);
	out << b1;
	return 0;
}

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "rational.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    Rational a(2, 3);
    cout << "a = " << a << endl;
    cout.flush();
 
    return app.exec();
}
 

C++ (Qt)
#ifndef RATIONAL_H
#define RATIONAL_H
 
#include <QTextStream>
 
namespace RationalStuff {
class Rational;
}
 
class Rational
{
public:
    Rational(int numerator = 0, int denominator = 1);
 
    int numerator() const;
    void setNumerator(const int numerator);
 
    int denominator() const;
    void setDenominator(const int denominator);
 
//    friend const Rational operator*(const Rational& lhs, const Rational& rhs);
//    friend const Rational operator+(const Rational& lhs, const Rational& rhs);
//    friend const Rational operator-(const Rational& lhs, const Rational& rhs);
    friend QTextStream& operator<<(QTextStream& stream, const Rational& r);
 
private:
    int mNumerator;
    int mDenominator;
};
 
#endif // RATIONAL_H
 

C++ (Qt)
#include "rational.h"
 
Rational::Rational(int numerator, int denominator) :
    mNumerator(numerator),
    mDenominator(denominator)
{
}
 
int Rational::numerator() const
{
    return mNumerator;
}
 
void Rational::setNumerator(const int numerator)
{
    mNumerator = numerator;
}
 
int Rational::denominator() const
{
    return mDenominator;
}
 
void Rational::setDenominator(const int denominator)
{
    mDenominator = denominator;
}
 
QTextStream &Rational::operator<<(QTextStream &stream, const Rational &r)
{
    stream << r.mNumerator << "/" << r.mDenominator;
    return stream;
}
 

C++ (Qt)
QTextStream &operator<<(QTextStream &stream, const Rational &r)
{
    stream << r.mNumerator << "/" << r.mDenominator;
    return stream;
}
 

C++ (Qt)
friend QTextStream& operator<<(QTextStream& stream, const Rational& r);

C++ (Qt)
#ifdef QT_VERSION
...
#endif

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "shape.h"
#include "circle.h"
#include "rectangle.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
void printShapeInfo(Shape *ps) {
    cout << "p = " << ps->perimeter() << endl;
    cout << "s = " << ps->area() << endl;
    cout.flush();
}
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Shape *pc = new Circle();
    printShapeInfo(pc);
 
    pc->calcPerimeter(2.5);
 
    return a.exec();
}
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
class Shape
{
public:
    Shape();
    virtual ~Shape();
 
    virtual void calcPerimeter() = 0;
    virtual void calcArea() = 0;
 
    double perimeter();
    double area();
 
protected:
    double mPerimeter;
    double mArea;
};
 
#endif // SHAPE_H
 

C++ (Qt)
#include "shape.h"
 
Shape::Shape() :
    mPerimeter(0.0),
    mArea(0.0)
{
}
 
Shape::~Shape()
{
}
 
double Shape::perimeter()
{
    return mPerimeter;
}
 
double Shape::area()
{
    return mArea;
}
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include "shape.h"
 
class Circle : public Shape
{
public:
    Circle();
    virtual double calcPerimeter(double radius);
    virtual double calcArea(double radius);
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#include "circle.h"
#include <cmath>
 
Circle::Circle()
{
}
 
double Circle::calcPerimeter(double radius)
{
    mPerimeter = 2.0 * M_PI * radius;
    return mPerimeter;
}
 
double Circle::calcArea(double radius)
{
    mArea = M_PI * radius * radius;
    return mArea;
}
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
class Rectangle : public Shape
{
public:
    Rectangle();
    virtual double calcPerimeter(double a, double b);
    virtual double calcArea(double a, double b);
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
#include "rectangle.h"
 
Rectangle::Rectangle()
{
}
 
double Rectangle::calcPerimeter(double a, double b)
{
    mPerimeter = 2.0 * (a + b);
    return mPerimeter;
}
 
double Rectangle::calcArea(double a, double b)
{
    mArea = a * b;
    return mArea;
}
 

C++ (Qt)
    template <typename stream_type>
    friend stream_type& operator<<(stream_type& stream, const Rational& r);
 

C++ (Qt)
template <typename stream_type>
stream_type &operator<<(stream_type &stream, const Rational &r)
{
    stream << r.mNumerator << "/" << r.mDenominator;
    return stream;
}
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "rational.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    Rational a(2, 3);
    cout << "a = " << a << endl;
    cout.flush();
 
    return app.exec();
}
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
class Shape
{
    // ...
    virtual void calcPerimeter() = 0;
    virtual void calcArea() = 0;
    // ...
};
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include "shape.h"
 
class Circle : public Shape
{
public:
    Circle();
    double calcPerimeter(double radius);
    double calcArea(double radius);
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
class Rectangle : public Shape
{
public:
    Rectangle();
    double calcPerimeter(double a, double b);
    double calcArea(double a, double b);
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include "shape.h"
 
class Circle : public Shape
{
public:
    Circle(double radius);
    double calcPerimeter();
    double calcArea();
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
class Rectangle : public Shape
{
public:
    Rectangle(double a, double b);
    double calcPerimeter();
    double calcArea();
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
class Rectangle : public Shape
{
public:
    Rectangle();
    double calcPerimeter(double a, double b);
    double calcArea(double a, double b);
};
 

C++ (Qt)
public:
    Rectangle();
    static double calcPerimeter(double a, double b);
    static double calcArea(double a, double b);
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "rational.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
 
    Rational a(2, 3); // 2/3
    cout << "a = " << a << endl;
    cout.flush();
 
    return app.exec();
}
 

C++ (Qt)
#ifndef RATIONAL_H
#define RATIONAL_H
 
namespace RationalStuff {
class Rational;
}
 
class Rational
{
public:
    Rational(int numerator = 0, int denominator = 1);
 
    int numerator() const;
    void setNumerator(int numerator);
 
    int denominator() const;
    void setDenominator(int denominator);
 
    friend const Rational operator*(const Rational& lhs, const Rational& rhs);
    friend const Rational operator+(const Rational& lhs, const Rational& rhs);
    friend const Rational operator-(const Rational& lhs, const Rational& rhs);
    template <typename stream_type>
    friend stream_type& operator<<(stream_type& stream, const Rational& r);
 
private:
    int mNumerator;
    int mDenominator;
};
 
template <typename stream_type>
stream_type &operator<<(stream_type &stream, const Rational &r)
{
    stream << r.mNumerator << "/" << r.mDenominator;
    return stream;
}
 
#endif // RATIONAL_H
 

C++ (Qt)
#include "rational.h"
 
Rational::Rational(int numerator, int denominator) :
    mNumerator(numerator),
    mDenominator(denominator)
{
}
 
int Rational::numerator() const
{
    return mNumerator;
}
 
void Rational::setNumerator(int numerator)
{
    mNumerator = numerator;
}
 
int Rational::denominator() const
{
    return mDenominator;
}
 
void Rational::setDenominator(int denominator)
{
    mDenominator = denominator;
}
 
const Rational operator*(const Rational &lhs, const Rational &rhs)
{
    return Rational(lhs.mNumerator * rhs.mNumerator,
                    lhs.mDenominator * rhs.mDenominator);
}
 
const Rational operator+(const Rational &lhs, const Rational &rhs)
{
    Rational result;
 
    // Общий знаменатель
    int commonDenominator = lhs.denominator() * rhs.denominator();
 
    // Числитель
    int a = lhs.numerator() * rhs.denominator();
    int b = rhs.numerator() * lhs.denominator();
    result.setNumerator(a + b);
 
    // Знаменатель
    result.setDenominator(commonDenominator);
 
    return result;
}
 
const Rational operator-(const Rational &lhs, const Rational &rhs)
{
    Rational result;
 
    // Общий знаменатель
    int commonDenominator = lhs.denominator() * rhs.denominator();
 
    // Числитель
    int a = lhs.numerator() * rhs.denominator();
    int b = rhs.numerator() * lhs.denominator();
    result.setNumerator(a - b);
 
    // Знаменатель
    result.setDenominator(commonDenominator);
 
    return result;
}
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "shape.h"
#include "circle.h"
#include "rectangle.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
void printShapeInfo(Shape *ps) {
    cout << "p = " << ps->perimeter() << endl;
    cout.flush();
    cout << "s = " << ps->area() << endl;
    cout.flush();
}
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Shape *pc = new Circle(3.0);
    pc->calcPerimeter();
    pc->calcArea();
    printShapeInfo(pc);
    delete pc;
 
    Shape *pr = new Rectangle(5, 10);
    pr->calcPerimeter();
    pr->calcArea();
    printShapeInfo(pr);
    delete pr;
 
    return a.exec();
}
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
class Shape
{
public:
    Shape();
    virtual ~Shape();
 
    virtual double calcPerimeter() = 0;
    virtual double calcArea() = 0;
 
    double perimeter() const;
    double area() const;
 
protected:
    double mPerimeter;
    double mArea;
};
 
#endif // SHAPE_H
 

C++ (Qt)
#include "shape.h"
 
Shape::Shape() :
    mPerimeter(0.0),
    mArea(0.0)
{
}
 
Shape::~Shape()
{
}
 
double Shape::perimeter() const
{
    return mPerimeter;
}
 
double Shape::area() const
{
    return mArea;
}
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include "shape.h"
 
class Circle : public Shape
{
public:
    Circle(double r = 0.0);
 
    /*virtual*/ double calcPerimeter();
    /*virtual*/ double calcArea();
 
    void setRadius(double r);
    double radius() const;
 
private:
    double mRadius;
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#include "circle.h"
#include <cmath>
 
Circle::Circle(double r) :
    mRadius(r)
{
}
 
/*virtual*/ double Circle::calcPerimeter()
{
    mPerimeter = 2.0 * M_PI * mRadius;
    return mPerimeter;
}
 
/*virtual*/ double Circle::calcArea()
{
    mArea = M_PI * mRadius * mRadius;
    return mArea;
}
 
void Circle::setRadius(double r)
{
    mRadius = r;
}
 
double Circle::radius() const
{
    return mRadius;
}
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
class Rectangle : public Shape
{
public:
    Rectangle(double l = 0.0, double w = 0.0);
 
    /*virtual*/ double calcPerimeter();
    /*virtual*/ double calcArea();
 
    void setLength(double l);
    double length() const;
 
    void setWidth(double w);
    double width() const;
 
private:
    double mLength;
    double mWidth;
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
#include "rectangle.h"
 
Rectangle::Rectangle(double l, double w) :
    mLength(l),
    mWidth(w)
{
}
 
/*virtual*/ double Rectangle::calcPerimeter()
{
    mPerimeter = 2.0 * (mLength + mWidth);
    return mPerimeter;
}
 
/*virtual*/ double Rectangle::calcArea()
{
    mArea = mLength * mWidth;
    return mArea;
}
 
void Rectangle::setLength(double l)
{
    mLength = l;
}
 
double Rectangle::length() const
{
    return mLength;
}
 
void Rectangle::setWidth(double w)
{
    mWidth = w;
}
 
double Rectangle::width() const
{
    return mWidth;
}
 

C++ (Qt)
/*virtual*/ double Rectangle::calcPerimeter()
{
    mPerimeter = 2.0 * (mHeight + mWidth);
    return mPerimeter;
}
 
/*virtual*/ double Rectangle::calcArea()
{
    mArea = mHeight * mWidth;
    return mArea;
}
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
class Shape
{
public:
    Shape();
    virtual ~Shape();
 
    virtual double calcPerimeter() = 0;
    virtual double calcArea() = 0;
 
    double perimeter() const;
    double area() const;
 
protected:
    double mPerimeter;
    double mArea;
};
 
#endif // SHAPE_H
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "circle.h"
#include "rectangle.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Circle *pc = new Circle;
    double radius = 5.5;
    cout << endl;
    cout << "Circle:" << endl;
    cout << "Radius = " << radius << endl;
    cout << "Perimeter = " << pc->perimeter(radius) << endl;
    cout << "Area = " << pc->area(radius) << endl;
    cout.flush();
    delete pc;
 
    Rectangle *pr = new Rectangle;
    double height = 5.0;
    double width = 10.0;
    cout << endl;
    cout << "Rectangle:" << endl;
    cout << "Height = " << height << endl;
    cout << "Width = " << width << endl;
    cout << "Perimeter = " << pr->perimeter(height, width) << endl;
    cout << "Area = " << pr->area(height, width) << endl;
    cout.flush();
    delete pr;
 
    return a.exec();
}
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include <cmath>
 
class Circle
{
public:
    inline double perimeter(double radius) const {
        return (2.0 * M_PI * radius);
    }
 
    inline double area(double radius) const {
        return (M_PI * radius * radius);
    }
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
class Rectangle
{
public:
    inline double perimeter(double height, double width) const {
        return 2.0 * (height + width);
    }
 
    inline double area(double height, double width) const {
        return height * width;
    }
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
setName("test"); 

C++ (Qt)
setName("test"); 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
class Person {
public:
    void setName(const QString& name) {
        mName = name;
    }
 
    QString name() const {
        return mName;
    }
private:
    QString mName;
};
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Person ivan("Ivan");
 
    return a.exec();
}
 

C++ (Qt)
class Circle
{
public:
    inline double perimeter(double radius) const {
        return (2.0 * M_PI * radius);

C++ (Qt)
class Circle : public Shape
{
public:
...
    static double perimeter(double radius) 
   {
        return (2.0 * M_PI * radius);
   }
 
   virtual double perimeter( void ) const
   {
      return perimeter(radius);
   }
 
private:  
  double m_radius;   
 

C++ (Qt)
class Shape
{
public:
    virtual ~Shape() {}
 
    virtual double perimeter() const = 0;
    virtual double area() const = 0;
};
 

C++ (Qt)
class Circle : public Shape
{
public:
    explicit Circle( double radius ) : m_radius( radius )
    {
    }
 
    double perimeter() const {
        return (2.0 * M_PI * m_radius);
    }
 
    double area() const {
        return (M_PI * m_radius * m_radius);
    }
 
private:
     double m_radius;
};
 

ivan.setName("Ivan");

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
class Person {
public:
    Person() {}
 
    Person(const QString& name) {
        mName = name;
    }
 
    void setName(const QString& name) {
        mName = name;
    }
 
    const QString& name() const {
        return mName;
    }
private:
    QString mName;
};
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Person ivan;
    ivan.setName("Ivan");
 
    cout << ivan.name() << endl;
    cout.flush();
 
    return a.exec();
}
 

C++ (Qt)
    Person(const QString& name) {
        mName = name;
    }
 

C++ (Qt)
Person(const QString& name) : mName(name) {}
 

C++ (Qt)
QRect GetRect( ... some args..) 

C++ (Qt)
QRect R = GetRect(...);  // вариант 1
 

C++ (Qt)
QRect R;
R = GetRect(...);  // вариант 2
 

C++ (Qt)
class Animal
{
public:
       Animal():alive(false){}
       ~Animal(){}
 
       bool isAlive(){return alive;}  // жив ли ?
       void birth(){alive = true;}    // рождение
       void death(){alive = false;} // смерть
 
private:
       bool alive;
}
 

C++ (Qt)
class Vertebrates : public Animal
{
public: 
        Vertebrates(int input)vertebras(inpupt), spine(ture){}
        ~Vertebrates(){}
 
        int getCountOfVertebras(){return vertebras;} // получить информацию о кол-ве позвонков
        bool hasSpine(){return spine;}
private:
        int vertebras;
        bool spine;
}
 

C++ (Qt)
#include <QCoreApplication>
#include <QTextStream>
#include "shape.h"
#include "circle.h"
#include "rectangle.h"
 
QTextStream cin(stdin);
QTextStream cout(stdout);
 
void printShapeInfo(Shape *ps) {
    cout << "p = " << ps->perimeter() << endl;
    cout.flush();
    cout << "s = " << ps->area() << endl;
    cout.flush();
}
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Shape *pc = new Circle(3.0);
    cout << "static perimeter: " << Circle::perimeter(3.0) << endl;
    printShapeInfo(pc);
    delete pc;
 
    Shape *pr = new Rectangle(5, 10);
    printShapeInfo(pr);
    delete pr;
 
    return a.exec();
}
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
class Shape
{
public:
 
    Shape() {}
    virtual ~Shape() {
 
    }
 
    virtual double perimeter() const = 0;
    virtual double area() const = 0;
};
 
#endif // SHAPE_H
 

C++ (Qt)
#ifndef CIRCLE_H
#define CIRCLE_H
 
#include "shape.h"
#include <cmath>
 
class Circle : public Shape
{
public:
    Circle(double radius = 0.0) : m_radius(radius) {
    }
 
    static double perimeter(double radius) {
        return (2.0 * M_PI * radius);
    }
 
    static double area(double radius) {
        return (M_PI * radius * radius);
    }
 
    virtual double perimeter() const {
        return perimeter(m_radius);
    }
 
    virtual double area() const {
        return area(m_radius);
    }
 
    inline double radius() const {
        return m_radius;
    }
 
    inline void setRadius(double radius) {
        m_radius = radius;
    }
 
private:
    double m_radius;
};
 
#endif // CIRCLE_H
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
class Rectangle : public Shape
{
public:
 
    Rectangle(double height = 0.0, double width = 0.0) :
        m_height(height),
        m_width(width)
    {
    }
 
    static double perimeter(double height, double width) {
        return 2.0 * (height + width);
    }
 
    static double area(double height, double width) {
        return height * width;
    }
 
    virtual double perimeter() const {
        return perimeter(m_height, m_width);
    }
 
    virtual double area() const {
        return area(m_height, m_width);
    }
 
    inline double height() const {
        return m_height;
    }
 
    inline double width() const {
        return m_width;
    }
 
    inline void setHeight(double height) {
        m_height = height;
    }
 
    inline void setWidth(double width) {
        m_width = width;
    }
 
private:
    double m_height;
    double m_width;
};
 
#endif // RECTANGLE_H
 

C++ (Qt)
class Viewer : public QGLWidget
{
public:
    // ...
    void draw(const Shape &ps, int xOffset, int yOffset, int pointSize = 2);
    // ...
}
 

C++ (Qt)
const QString & filePath1(..) const;
QString filePath2(..) const;
QString & filePath3(..);
 

C++ (Qt)
Circle *crcl = new Circle();
crcl->draw(x, y, rad);
 

C++ (Qt)
const QString & filePath1(..) const;

C++ (Qt)
const QString & filePath1(..) const
{
    QString result = prefix() + m_filePath + postfix();
    return result;
}
 

C++ (Qt)
#ifndef VIEWER_H
#define VIEWER_H
 
#include <QGLWidget>
#include "shape.h"
 
#include <vector>
 
class Viewer : public QGLWidget
{
public:
    // ...
    void addForPainting(const myShapes::Shape &ps);
 
    // ...
private:
    std::vector<myShapes::Shape> shapes;
    void draw(const myShapes::Shape &ps, int xOffset, int yOffset);
};
 
#endif // VIEWER_H
 

C++ (Qt)
#ifndef SHAPE_H
#define SHAPE_H
 
namespace myShapes {
 
class Shape
{
public:
    // ...
};
 
}
 
#endif // SHAPE_H
 

C++ (Qt)
#ifndef RECTANGLE_H
#define RECTANGLE_H
 
#include "shape.h"
 
namespace myShapes {
 
class Rectangle : public Shape
{
public:
    // ...
};
 
}
 
#endif // RECTANGLE_H
 

C++ (Qt)
class Shape : public QObject, public QGraphicsItem
{
        Q_OBJECT
 
    public:
        Shape ();
        ~Shape ();
        QRectF boundingRect() const;
        void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 
        ... // и так далее
}
 

C++ (Qt)
#include <QCoreApplication>
#include <QDebug>
 
// классы для представления геометрических фигур
class Shape {
public:
    enum ShapeColor { Red, Green, Blue };
 
    // все фигуры должны предоставлять функцию для рисования
    virtual void draw(ShapeColor color = Red) const = 0;
    // ...
 
    virtual ~Shape() {
 
    }
};
 
class Rectangle: public Shape {
public:
    // заметьте, другое значение параметра по умолчанию – плохо!
    virtual void draw(ShapeColor color = Green) const {
        qDebug() << color;
    }
};
 
class Circle: public Shape {
public:
    virtual void draw(ShapeColor color) const {
        qDebug() << color;
    }
};
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Shape *pr = new Rectangle;
    pr->draw();
    delete pr;
 
    return a.exec();
}
 

C++ (Qt)
class Rectangle: public Shape {
public:
    virtual void draw(ShapeColor color) const {
        qDebug() << color;
    }
};
 

C++ (Qt)
#include <QCoreApplication>
#include <QDebug>
 
class Shape {
public:
    enum ShapeColor { Red, Green, Blue };
    void draw(ShapeColor color = Red) const // теперь – невиртуальная
    {
        doDraw(color); // вызов виртуальной функции
    }
    // ...
private:
    virtual void doDraw(ShapeColor color) const = 0; // реальная работа выполняется в этой функции
};
 
class Rectangle: public Shape {
public:
    // ...
private:
    virtual void doDraw(ShapeColor color) const { // обратите внимание на отсутствие у аргумента значения по умолчанию
        qDebug() << color;
    }
};
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Shape *pr = new Rectangle;
    pr->draw();
    delete pr;
 
    return a.exec();
}
 

C++ (Qt)
const QString & base = obj.filePath1(..);
 

C++ (Qt)
namespace TriangulateUtils {
 
class TriangleLoop {
...
 

C++ (Qt)
namespace FontTriangulateUtils {
typedef TriangulateUtils::TriangleLoop TriangleLoop;
 

C++ (Qt)
#ifndef FUNCTIONS_FOR_HEALTHCALC_H
#define FUNCTIONS_FOR_HEALTHCALC_H
 
#include "gamecharacter.h"
 
namespace GameStuff {
 
// функция алгоритма по умолчанию для вычисления жизненной силы персонажа
int defaultHealthCalc(const GameCharacter& gc);
 
// функции вычисления жизненной силы с разным поведением
int loseHealthQuickly(const GameCharacter& gc);
int loseHealthSlowly(const GameCharacter& gc);
 
}
 
#endif // FUNCTIONS_FOR_HEALTHCALC_H
 

C++ (Qt)
namespace GameStuff {
 
class GameCharacter; 
 
// функция алгоритма по умолчанию для вычисления жизненной силы персонажа
int defaultHealthCalc(const GameCharacter& gc);
 
// функции вычисления жизненной силы с разным поведением
int loseHealthQuickly(const GameCharacter& gc);
int loseHealthSlowly(const GameCharacter& gc);
 
}

C++ (Qt)
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    // однотипные персонажи с разным поведением относительно здоровья
    GameStuff::EvilBadGay ebg1(GameStuff::loseHealthQuickly);
    GameStuff::EvilBadGay ebg2(GameStuff::loseHealthSlowly);
 
    return a.exec();
}