1
  1. Этот сайт использует файлы cookie. Продолжая пользоваться данным сайтом, Вы соглашаетесь на использование нами Ваших файлов cookie. Узнать больше.
Приветствуем вас,Гость, на форуме IFUD.WS. Обязательно рекомендуется к прочтению правила форума http://ifud.ws/threads/obnovleno-pravila-foruma.7759

ООП в С++

Тема в разделе "Программирование", создана пользователем vladyxa13, 10 янв 2014.

  1. TopicStarter Overlay
    vladyxa13

    vladyxa13

    Регистрация:
    5 янв 2014
    Сообщения:
    9
    Симпатии:
    3
    Объектно-ориентированное программирование(ООП)


    Объектно-ориентированное программирование(ООП) - важная составляющая программирования, которая получает все большее распространение.
    ООП позволяет разложить проблему на связанные между собой задачи. Каждая проблема становится самостоятельным объектом, содержащим свои собственные коды и данные, которые относятся к этому объекту. В этом случае исходная задача в целом упрощается, и программист получает возможность оперировать с большими по объему программами.
    В этом определении ООП отражается известный подход к решению сложных задач, когда мы разбиваем задачу на подзадачи и решаем эти подзадачи по отдельности. С точки зрения программирования подобный подход значительно упрощает разработку и отладку программ.
    В объектно-ориентированном программировании, структуры данных и алгоритмы интегрированы в модули, часто называемые классами.
    Название "Объектно-ориентированное программирование" говорит само за себя. Центром внимания ООП является объект.
    Объект состоит из структуры данных и связанных с ней функций (которые называются методами), которые работают с данными, записанными в экземплярах структуры данных. Все является объектом. Объект как хранит информацию, так и способен ее преобразовывать. В принципе любой элемент решаемой задачи (дом, собака, услуга, химическая реакция, город, космический корабль и т. д.) может представлять собой объект. Объект можно представить себе как швейцарский нож: он является набором различных ножей и «открывашек» (хранение), но в то же самое время им мы можем резать или открывать что-либо (преобразование)
    Объект ООП - это совокупность переменных состояния и связанных с ними методов(операций). Эти методы определяют как объект взаимодействует с окружающим миром.
    Возможность управлять состояниями объекта посредством вызова методов в итоге и определять поведение объекта. Эту совокупность методов часто называют интерфейсом объекта.

    Термины ООП:

    Поскольку C++ – объектно-ориентированный язык, он позволяет использовать при разработке программ как готовые классы, доступные через соответствующие библиотеки, так и классы, разработанные пользователем.
    Класс - это группа данных и методов(функций) для работы с этими данными. Объекты с одинаковыми свойствами, то есть с одинаковыми наборами переменных состояния и методов, образуют класс.
    Объект (object)- это конкретная реализация, экземпляр класса. В программировании отношения объекта и класса можно сравнить с описанием переменной, где сама переменная(объект) является экземпляром какого-либо типа данных(класса). Объект – совокупность свойств (параметров) определенных сущностей и методов их обработки (программных средств) (объект содержит инструкции (программный код), определяющий действия, которые может выполнять объект, и обрабатываемые данные);
    Обычно, если объекты соответствуют конкретным сущностям реального мира, то классы являются некими абстракциями, выступающими в роли понятий. Понятие класса и что он в себя включает мы рассмотрим отдельно. А на данном этапе воспринимайте класс как шаблон объекта. Для формирования какого-либо реального объекта необходимо иметь шаблон, на основании которого и строится создаваемый объект. При рассмотрении основ ООП мы часто смешиваем понятие объекта и класса. Дело в том, что класс - это некоторое абстрактное понятие. Для проведения аналогий или приведения примеров оно не очень подходит. На много проще приводить примеры, основываясь на объектах из реального мира, а не на абстрактных понятиях. Поэтому, говоря, к примеру, про наследование мы прежде всего имеем ввиду наследование классов(шаблонов), а не объектов, хотя часто и применяем слово объект. Скажем так: объект - это физическая реализация класса(шаблона).
    Свойство объекта (propertis)– характеристика объекта, представленная в виде переменной, являющейся членом класса.
    Методы объекта (methods)- это подпрограмма, входящая в состав класса и управляющая данными объекта.
    События объекта (events) - какое-либо происшествие в программе, системе, например, была нажата кнопка мыши. Другими словами, изменение состояния объекта;
    Класс объектов (class) – совокупность объектов, характеризующихся общностью применяемых методов обработки или свойств.
    Сообщение (message)- адресованная конкретному объекту информация о происшедшем событии; объект, получивший сообщение, должен на него ответить своими действиями, вызвав метод, соответствующий этому событию. Например, если получено сообщение о том, что была нажата левая кнопка мыши на пункте меню Exit, произойдет завершение программы, если был выбран пункт меню Save, будет выполнено сохранение информации. Это практически то же самое, что и вызов функций в обычном программировании. В ООП обычно употребляется выражение "послать сообщение" какому-либо объекту. Понятие "сообщение" в ООП можно объяснить с точки зрения основ ООП: мы не можем напрямую изменить состояние объекта и должны как бы послать сообщение объекту, что мы хотим так и так изменить его состояние. Объект сам меняет свое состояние, а мы только его просим об этом посылая сообщения.
    Ключевые черты ООП.
    Несмотря на то, что в различных источниках делается акцент на те или иные особенности внедрения и применения ООП, 3 основных (базовых) понятия ООП остаются неизменными.


    К ним относятся:
    • Наследование (Inheritance)
    • Инкапсуляция (Encapsulation)
    • Полиморфизм (Polymorphism)
    Эти понятия, как три кита, лежат в основе мира ООП.
    Инкапсуляция является одним из ключевых понятий ООП.Инкапсуляция - это механизм, который объединяет данные и методы, манипулирующие этими данными, и защищает и то и другое от внешнего вмешательства или неправильного использования. Когда методы и данные объединяются таким способом, создается объект.
    Итак, зачем же нам нужна инкапсуляция? Ответ прост, мы - люди. А человеку свойственно ошибаться. Никто не застрахован от ошибок. Применяя инкапсуляцию, мы, как бы, возводим крепость, которая защищает данные, принадлежащие объекту, от возможных ошибок, которые могут возникнуть при прямом доступе к этим данным. Кроме того, применение этого принципа очень часто помогает локализовать возможные ошибки в коде программы. А это на много упрощает процесс поиска и исправления этих ошибок.
    Можно сказать, что инкапсуляция подразумевает под собой скрытие данных (data hiding), что позволяет защитить эти данные.
    Суть инкапсуляции:
    Переменные состояния объекта скрыты от внешнего мира. Изменение состояния объекта (его переменных) возможно ТОЛЬКО с помощью его методов(операций).
    Почему же это так важно ? Этот принцип позволяет защитить переменные состояния объекта от неправильного их использования.
    Это существенно ограничивает возможность введения объекта в недопустимое состояние и/или несанкционированное разрушение этого объекта.
    Инкапсуляция – это скрытие от пользователя классом его полей. Т.е. все поля (прееменные) класса Вы делаете скрытыми (private), а методы открытыми (public). Т.о. можна будет взаимодействовать со свойствами класса через методы.

    Пример инкапсурирования

    main.cpp
    Код:
    #include <iostream>
    #include <locale>
    #include <conio.h>
    #include "Account.h"
     
    using namespace std;
    using P::Account;
     
    int main()
    {
        Account akk;
     
        akk.setID("#672290");
        akk.setBalance(2000);
        akk.setName("vladyxa13");
     
        cout << "Id: " << akk.getID() << endl;
        cout << "Name: " << akk.getName() << endl;
        cout << "Balance: " << akk.getBalance();
     
    _getch();
    return 0;
    }
    
    Account.h
    Код:
    #pragma once
     
     
    namespace P
    {    
        typedef unsigned int ui;
     
        class Account
        {    
        private:
            char* id;
            char* name;
            ui balance;
        public:
            Account(void);
            void setBalance(ui b);
            ui getBalance();
            void setName(char* Name);
            char* getName();
            void setID(char* ID);
            char* getID();
            ~Account(void);
        };
     
     
    }
    
    Account.cpp
    Код:
    #include "Account.h"
     
     
    namespace P
    {
    Account::Account(void)
    {
    }
     
     
    void Account::setID(char* ID)
    {
        id = ID;
    }
     
     
    void Account::setName(char* Name)
    {
        name = Name;
    }
     
    ui Account::getBalance()
    {
        return balance;
    }
     
    char* Account::getID()
    {
        return id;
    }
     
    char* Account::getName()
    {
        return name;
    }
     
    void Account::setBalance(ui b)
    {
        balance = b;
    }
     
    Account::~Account(void)
    {
    }
    }
    
    Вторая ключевая черта, — наследование — это процесс, посредством которого, один объект может наследовать свойства другого объекта и добавлять к ним черты, характерные только для него.
    В описаниях языков ООП принято класс, из которого наследуют называть родительским классом (parent class) или основой класса(base class). Класс, который получаем в результате наследования называется порожденным классом или дочерним (derived or child class). Родительский класс всегда считается более общим и развернутым. Порожденный же класс всегда более строгий и конкретный, что делает его более удобным в применении при конкретной реализации.
    Как вывод из всего сказанного приведу следующее мнение, что:
    ООП - это процесс построения иерархии классов. А одним из наиболее важных свойств ООП является механизм, по которому типы классов могут наследовать характеристики из более простых, общих типов. Этот механизм называется наследованием. Наследование обеспечивает общность функций, в то же время допуская столько особенностей, сколько необходимо.

    В C++ существует три типа наследования:
    • public(открытое)
    • protected(защищенное)
    • private(закрытое)
    Открытое (public) наследование отражает зависимость «являться». Все члены базового класса становятся членами класса-наследника (как интерфейс, так и реализация).
    Спецификатор доступа protected аналогичен private, только он позволяет получить доступ к защищённым данным из производного класса. Когда в программе вы будете применять наследование, то вместо спецификатора private всегда используйте protected.
    С помощью наследования удобно строить иерархию классов. При этом более общие и абстрактные классы - базовые, а более специализированные - производные.
    Если класс объявлен как базовый для другого класса со спецификатором доступа public, тогда public члены базового класса доступны как public члены производного класса, protected члены базового класса доступны как protected члены производного класса.
    Если класс объявлен как базовый для другого класса со спецификатором доступа protected, тогда public и protected члены базового класса доступны как protected члены производного класса.
    Если класс объявлен как базовый для другого класса со спецификатором доступа private, тогда public и protected члены базового класса доступны как private члены производного класса.
    Одним из основных преимуществ public-наследования является то, что указатель на классы-наследники может быть неявно преобразован в указатель на базовый класс.

    Код:
    #include <iostream>
    using namespace std;
    class BaseClass
    {                //базовый класс
    public:
        BaseClass();
        ~BaseClass();
        int Val;
    };
    class Inheritance_Public : public BaseClass
    {    //public  наследование
        public:
        int PublVal;
    };
    class Inheritance_Protected : protected BaseClass
    {    //protected наследование
        public:
        int PrtcVal;
    };
    class Inheritance_Private : private BaseClass
    {    //private наследование
        public:
        int PrvVal;
    };
    int main()
    {
        Inheritance_Public objInheritance_Public;
        objInheritance_Public.PublVal = 10;
        objInheritance_Public.Val = 20;
        Inheritance_Protected objIInheritance_Protected;
        objIInheritance_Protected.PrtcVal = 30;
        objIInheritance_Protected.Val = 40;
        Inheritance_Private objInheritance_Private;
        objInheritance_Private.PrvVal = 50;
        objInheritance_Private.Val = 60;
        return 0;
    }
    
    Код вверху не прокатит.

    Таким образом если дочерний класс создается как protected или private, то переменные базового(родительского) класса недоступны дочернему.
    Третья черта, известная как полиморфизм - это свойство, которое позволяет одно и тоже имя использовать для решения нескольких технически разных задач. Это делает классы ещё удобнее и делает облегчает расширение и поддержку программы, основанных на них.
    В общем смысле, концепцией полиморфизма является идея "один интерфейс, множество методов". Это означает, что можно создать общий интерфейс для группы близких по смыслу действий.
    Преимуществом полиморфизма является то, что он помогает снижать сложность программ, разрешая использование одного интерфейса для единого класса действий. Выбор конкретного действия, в зависимости от ситуации, возлагается на компилятор.
    Применительно к ООП, целью полиморфизма, является использование одного имени для задания общих для класса действий. На практике это означает способность объектов выбирать внутреннюю процедуру (метод) исходя из типа данных, принятых в сообщении.

    Пример:
    Код:
    #include <iostream>
    using namespace std;
     
    class convert {
    protected:
      double val1;  // initial value
      double val2;  // converted value
    public:
      convert(double i) {
        val1 = i;
      }
      double getconv() { return val2; }
      double getinit() { return val1; }
     
      virtual void compute() = 0;
    };
     
    // Liters to gallons.
    class l_to_g : public convert {
    public:
      l_to_g(double i) : convert(i) { }
      void compute() {
        val2 = val1 / 3.7854;
      }
    };
     
    // Fahrenheit to Celsius
    class f_to_c : public convert {
    public:
      f_to_c(double i) : convert(i) { }
      void compute() {
        val2 = (val1-32) / 1.8;
      }
    };
     
    //Futs to meters
    class f_to_m : public convert {
    public:
      f_to_m(double i) : convert(i) { }
      void compute() {
        val2 = val1 / 3.28;
      }
    };
     
    int main()
    {
      convert *p;  // pointer to base class
     
      l_to_g lgob(4);
      f_to_c fcob(70);
     
      // use virtual function mechanism to convert
      p = &lgob;
      cout << p->getinit() << " liters is ";
      p->compute();
      cout << p->getconv() << " gallons\n";  // l_to_g
     
      p = &fcob;
      cout << p->getinit() << " in Fahrenheit is ";
      p->compute();
      cout << p->getconv() << " Celsius\n";  // f_to_c
     
      return 0;
    }
    
    Программа — совокупность объектов, указывающих друг другу что делать. Для обращения к одному объекту другой объект «посылает ему сообщение». Как вариант возможно и «ответное сообщение». Программу можно представить себе как совокупность к примеру 3 объектов: писателя, ручки и листа бумаги. Писатель «посылает сообщение» ручке, которая в свою очередь «посылает сообщение» листу бумаги — в результате мы видим текст (посыл сообщения от листа к писателю).
    Каждый объект имеет свою собственную «память» состоящую из других объектов. Таким образом программист может скрыть сложность программы за довольно простыми объектами. К примеру, дом (достаточно сложный объект) состоит из дверей, комнат, окон, проводки и отопления. Дверь, в свою очередь, может состоять из собственно двери, ручки, замка и петель. Проводка тоже состоит из проводов, розеток и к примеру щитка.
    У каждого объекта есть тип. Иногда тип называют еще и классом. Класс (тип) определяет какие сообщения объекты могут посылать друг другу. Например, аккумуляторная батарея может передавать электролампе ток, а вот момент или физическое усилие - нет.
    Все объекты одного типа могут получать одинаковые сообщения. К примеру у нас есть 2 объекта: синяя и красная кружки. Обе разные по форме и материалу. Но из обеих мы можем пить (или не пить, если они пустые). В данном случае кружка — это тип объекта.
    Объекты могут иметь идентичную структуру и отличаться только значениями свойств. В таких случаях в программе создается новый тип, основанный на единой структуре объекта. Он называется классом, а каждый конкретный объект, имеющий структуру этого класса, называется экземпляром класса.
    Класс объектов – совокупность объектов, характеризующихся общностью применяемых методов обработки или свойств.
    Другими словами, класс - это тип данных, а объект - экземпляр типа класс.
    Класс (class) - это группа данных и методов(функций) для работы с этими данными. По сути это шаблон. Объекты с одинаковыми свойствами, то есть с одинаковыми наборами переменных состояния и методов, образуют класс. Класс - это механизм для создания новых типов.
    Примерная структура класса ( не привязана к какому-либо языку ООП) :
    Код:
    Class  имя_класса  [ от кого унаследован]
    {
    private:
    . . . . . . .
    public:
    . . . . . . .
    protected:
    . . . . . . .
    }
    Объявление класса:
    class <имя класса>
    {
    public:
    <объявление переменных, констант, функций>
    private:
    <объявление переменных, констант, функций>
    protected:
    <объявление переменных, констант, функций>
    };
    Объявление класса начинается с ключевого слова class. Переменные, константы, функции, включенные в класс, называются членами класса. Члены класса объявляются в одном из трех разделов класса: public, private, protected. Включение члена класса в тот или иной раздел влияет на доступность этого члена для объектов других классов.
    Класс должен иметь уникальное имя. Если он наследован из другого, то надо указать имя родительского(их) класса(ов
    Если раздел private включен в объявлении класса первым, ключевое слово private можно опустить и, если не объявлено начало ни одного из других разделов описания класса, считается, что данные относятся к разделу private.
    Методы (функции) в классе могут быть объявлены как дружественные (friend) или виртуальные (virtual). Иногда встречается объявление перегружаемых (overload) функций.
    Private(частный) раздел описания класса обычно находится вначале описания класса и содержит данные, доступ к которым закрыт из внешнего мира. Это и есть та самая "строго охраняемая" зона класса, доступ к которой можно получить только из методов самого класса. Она скрыта от внешнего мира глухой непробиваемой стеной и доступ к данным раздела private обеспечивается только с помощью, специально описанных в других разделах, методов. Скрытые в этом разделе данные также не доступны для всех производных классов.
    Если бы все данные, описанные в базовом (родительском) классе, были доступны для производных классов, то можно было бы просто создать суперкласс, а затем из производных классов получать свободный доступ ко все данным родительского класса. В то же время это перечеркнуло бы все наши старания по скрытию и защите данных. По этой причине, производные (наследуемые) классы автоматически не получают доступ к данным родительского класса (раздел private). Но бывают такие случаи, когда необходимо автоматически наследовать некоторые данные из родительского класса так, чтобы они вели себя так, как будто они описаны в производном классе . Именно для этих целей и существует раздел protected(защищенный) описания класса.
    protected(защищенный) - раздел описания класса содержит данные и методы, доступ к которым закрыт из внешней среды, но они напрямую доступны производным классам.
    Таким образом, раздел protected используется для описания данных и методов, которые будут доступны только из производных классов. А в производных классах эти данные и методы воспринимаются, как если бы они были описаны в самом производном классе.
    Раздел public означает открытый раздел. Методы описанные в разделе public доступны в пределах области видимости объекта и для производных классов. Таким образом, можно получить свободный доступ к методам, описанным в разделе public, из любого места программы (объект должен быть виден) и из любого производного класса. Методы, входящие в этот раздел, образуют интерфейс класса, с помощью которого и осуществляется взаимодействие экземпляра класса с внешним миром. Это единственный раздел, доступ к которому из внешней среды никак не ограничен.
    При указании базового(родительского) класса в описании класса в С++ требуется указать ключевое слово public. Указание этого ключевого слова позволит получить свободный доступ ко всем методам класса, как если бы они были описаны в самом производном классе. В противном же случае, мы не сможем получить доступ к методам родительского класса.

    Пример описания наследования классов на С++:
    Код:
    class A
    {
    . . . . .
    }
     
    class B : public A
    {
    . . . . .
    }
    [​IMG]

    Конструктор и деструктор
    Конструктор отвечает за начальное формирование (инициализацию) объекта на этапе его создания.
    Конструктор работает на отрезке времени с момента объявления (декларирования) объекта до момента инициализации (рождения). На этом этапе происходит формирование скелета объекта (инициализация). Можно провести аналогию с таким детским конструктором как Лего. У вас есть кубики или части определенной конфигурации и из них собираете какую-то конструкцию (фигуру, замок и т.д.). Таким образом, конструктор отвечает за начальное формирование(инициализацию) объекта на этапе его создания.
    В языке С++ конструктор имеет тоже самое имя, что и имя класса и не может иметь какой-либо определенный возвращаемый тип, поскольку имеет заранее определенный возвращаемый тип - указатель на инициализируемый объект.
    Следует отметить, что функция конструктора запускается на этапе описания (декларирования) объекта. Т.е. декларирование объекта MyObject класса CMyObject следующей строкой
    Код:
    CMyObject  MyObject;
    
    приводит к вызову конструктора этого класса для данного объекта. Казалось бы, мы еще ничего не сделали с объектом, только описали, а какая-то функция уже выполняется ! Если декларирование объекта произведено до выполнения основного модуля, то функция конструктора будет выполнена до выполнения этого модуля.
    Деструктор начинает работать, когда объект готов завершить свою работу. При "умирании" объекта, "умирают" и ссылки на все блоки памяти, которые были выделены объекту в процессе работы. . Если мы не освободим выделенные объекту блоки памяти, то никто и не подумает их освобождать. В результате получится, что мы храним данные, которые нам уже абсолютно не нужны и мы даже не имеем к ним доступа ! В больших программах это может привести не только к краху самой программы, но и к замедлению работы или даже зависанию операционной системы. Деструктор должен корректно освобождать блоки памяти, выделенные при работе с этим объектом. Применение деструктора в этом случае помогает избежать утечек памяти(memory leaks).
    В языке С++ Деструктор имеет тоже имя, что и имя класса с предшествующей ему тильдой ~. Деструктор не имеет никакого возвращаемого типа.
    Пример класса с Конструктором и Деструктором в С++. Этот код не имеет никакого реального смысла, но наглядно показывает как можно использовать конструктор и деструктор.
    Код:
    сlass CMyClass
    {
      public:
        CMyClass();  // Конструктор класса CMyClass
        ~CMyClass();  // Деструктор класса CMyClass
    private:
      int MyInt;  // переменная типа integer (целое число)
      int *point; // переменная типа указатель на integer (целое число)
    };
    CMyClass::CMyClass()  // Конструктор
    {
    MyInt=10;  // На этапе инициализации объекта класса CMyClass присваиваем
                        // переменной этого объекта MyInt значение 10
     
    point = new int; // Выделяем блок памяти под целое число, на которое
                              // будет указывать указатель
    *point = 20;      //  Сохраняем в этот выделенный блок памяти число 20
    }
    CMyClass::~CMyClass()  // Деструктор
    {
    MyInt=0;  // Объект класса CMyClass уже фактически прекратил существование,
                      // но мы присваиваем переменной класса MyInt значение 0
    delete point; // Используем указатель на число для того, чтобы освободить
                        // блок памяти, выделенный под это число.
                        // Если мы этого здесь не сделаем, никто за нас это не сделает
    }
    
    Пример кода на применение инкапсуляции:
    Код:
    #include <iostream>
    #include <iomanip>
    using namespace std;
    class MyFirstClass
    {
    public:
            MyFirstClass ();
            ~MyFirstClass ();
            void Authentication (); //Функция проведения аутентификации
            void SetData (); //Функция установки значений
            void GetData (); //Функция получения и вычисления значений
    //  инкапсуляция, переменные класса доступны только через метод класса  Authentication
        private:
            char NameOfUser[50]; //Имя владельца счёта
            int AccountNumber; //Номер счёта
            int InitialBalance; //Начальный баланс (денег на счету)
            int SumIncome; //Количество входящих платежей
            int SumExpense; //Количество исходящих платежей
            int CurrentBalance; //Настоящий (текущий) баланс
            int CreditLimit; //Размер максимального кредита, при нулевом балансе на счету
            int MaximumSum; //Размер максимального кредита, при текущем балансе на счету
    };
    MyFirstClass::MyFirstClass ()
    {
        sprintf_s(NameOfUser,50,"anonymous");
        AccountNumber = 0000;
        InitialBalance = 0;
        SumIncome = 0;
        SumExpense = 0;
        CurrentBalance = 0;
        CreditLimit = 100;
        MaximumSum = 0;
    }
    MyFirstClass::~MyFirstClass ()
    {
     
    }
    void MyFirstClass::Authentication ()
    {
        int tempPass;
        int password = 1234;
        int pin = 4321;
        cout<<"Procedure authentication!\n"
            <<"Please enter password ("<<password<<"): ";
        cin>>tempPass;
        if (tempPass == password)
            {
                cout<<"You can enter information\n";
                SetData ();
            }
        if (tempPass == pin)
            {
                cout<<"You can get information\n";
                GetData ();
            }
        else
            {
                cout<<"Sorry, you not passed authentication...\n"
                    <<"Please, run program again!\n";
            }
    }
    void MyFirstClass::SetData ()
    {
        cout<<"Name: ?\b";
        gets_s(NameOfUser,50);
        cout<<"Number of account: ?\b";
        cin>>AccountNumber;
        cout<<"Initial balance: ?\b";
        cin>>InitialBalance;
        cout<<"Income sum: ?\b";
        cin>>SumIncome;
        cout<<"Expense sum: ?\b";
        cin>>SumExpense;
    }
    void MyFirstClass::GetData ()
    {
        cout<<"Name: "<<NameOfUser<<endl;
        cout<<"Number of account: "<<AccountNumber<<endl;
        cout<<"Initial balance: "<<InitialBalance<<endl;
        cout<<"Income sum: "<<SumIncome<<endl;
        cout<<"Expense sum: "<<SumExpense<<endl;
        CurrentBalance = InitialBalance + SumIncome - SumExpense;
        cout<<"Current balance: "<<CurrentBalance<<endl;
        MaximumSum = CurrentBalance + CreditLimit;
        cout<<"Maximum sum: "<<MaximumSum<<endl;
    }
    MyFirstClass ClassObject;
    int main(int argc, _TCHAR* argv[])
    {
        cout<<"Hello, programmer!\n";
        ClassObject.Authentication ();
        ClassObject.Authentication ();
        cout<<"Done!\n";
        return 0;
    }
    
    Пример кода на применение полиморфизма

    Код:
    #include <iostream>
    using namespace std;
    class Base
    {
    public:
        virtual  void func()
        {
            cout << "Base::func()" <<endl;
        }
    };
    class Derived1 : public Base
    {
    public:
        void func()
        {
            cout << "Derived1::func()" << endl;
        }
    };
    class Derived2 : public Derived1
    {
    public:
        void func()
        {
            cout << "Derived2::func()" << endl;
        }
    };
    void base_call( Base& b)
    {
        b.func();
    }
    void derived_call( Derived1& d)
    {
        d.func();
    }
    int main(int argc, _TCHAR* argv[])
    {
        Base b;
        Derived1 d1;
        Derived2 d2;
     
        base_call(b);
        base_call(d1);
        base_call(d2);
        derived_call(d1);
        derived_call(d2);
     
        return 0;
    }
    

    Ну и на конец Классы и структуры

    Структуры можно использовать, как классы, они очень похожи, классы по сути и есть структуры с расширенными возможностями. В классах все данные автоматически закрыты, а в структурах открыты. Самое ощутимое для меня в классах это перегрузка операторов, в структурах это не поддерживается.

    Класс
    Код:
    class employee {
      char str[255];
    public:
      void buildstr(char *s);
    void showstr();
    };
    Структура
    Код:
    struct mystr {
      void buildstr(char *s); // public
      void showstr();
    private: // now go private
      char str[255];
    } ;

    В статье использовались источники: Г.Шилдт "Полный справочник по С++" и Лекция по С++, свой материал.

    Please login or register to view links

    Примечание:

    Если у вас компилятор не MS VC++, а какой-то другой, то возможно некоторый код работать не будет. Что бы привести в рабочие состояние нужно заменить директиву
    Код:
    #pragma once
    на

    Код:
    #ifndef _НазваниеНашегоЗаголовочногоФайла_H_
    #define _НазваниеНашегоЗаголовочногоФайла_H_
    .
    .
    .
    #endif // _НазваниеНашегоЗаголовочногоФайла_H_
     
    Метки:
  2. usFire

    usFire

    Регистрация:
    20 авг 2012
    Сообщения:
    274
    Симпатии:
    177
    напиши зверька под iphone , android , linux .
     
  3. TopicStarter Overlay
    vladyxa13

    vladyxa13

    Регистрация:
    5 янв 2014
    Сообщения:
    9
    Симпатии:
    3
    Не понял? Приложение, крос платформу?
     
  4. usFire

    usFire

    Регистрация:
    20 авг 2012
    Сообщения:
    274
    Симпатии:
    177
    вредоносный софт
     
  5. TopicStarter Overlay
    vladyxa13

    vladyxa13

    Регистрация:
    5 янв 2014
    Сообщения:
    9
    Симпатии:
    3
    Я планировал написать ботнет, но когда делаешь ботнет с "адм у себя дома" ты палишь свой IP, так как команда идет на прямую к нему или от него. Вот в чем минус, пилить сайт под это...мм идея хороша так как можно сделать не Я->Боты, а Я->Прокси сервер->Админка->Боты, да и продавать удобней, так как ты всего лишь даешь пасс и логин от сайта, а так надо привязку делать, потом IP свой палить, не то. Но можно хотя быпо пробовать так а потом с адм. Дык только руки до этого не доходят, так как надо для одного форума статью большую дописать(тоже для новичков, типа моя трилогия), думаю ботов сия реализовать на C#.

    Если бы кто-то по опытней меня хотел бы помочь реализовать эту идея, я только за;) . Главное обмен опыта.
     

Поделиться этой страницей

Загрузка...