Отправляет email-рассылки с помощью сервиса Sendsay

RFpro.ru: Программирование на C / C++

Подписаться Бесплатная «Золотая» новостная рассылка . Подписчиков 5.423 RSS
←   Июнь 2009   →
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


За последние 60 дней ни разу не выходила


Сайт рассылки: http://prog.rusfaq.ru/C
Открыта: 14-03-2002

Автор
Калашников О.А.

Статистика

5.423 подписчиков
0 за неделю
←   Все выпуски   →

RusFAQ.ru: Программирование на C / C++


Хостинг портала RFpro.ru:
Московский хостер
Профессиональный платный хостинг на базе Windows 2008

РАССЫЛКИ ПОРТАЛА RFPRO.RU

Чемпионы рейтинга экспертов в этой рассылке

_Ayl_
Статус: 7-й класс
Рейтинг: 538
∙ повысить рейтинг >> 		Micren
Статус: Практикант
Рейтинг: 297
∙ повысить рейтинг >> 		AMV007
Статус: 3-й класс
Рейтинг: 142
∙ повысить рейтинг >>

∙ / КОМПЬЮТЕРЫ И ПО / Языки программирования / C/C++

Выпуск № 1340 от 23.06.2009, 23:05
Администратор рассылки: Dr_Andrew, Модератор
В рассылке: подписчиков - 627, экспертов - 146
В номере: вопросов - 2, ответов - 2

Нам очень важно Ваше мнение об этом выпуске рассылки. Вы можете оценить этот выпуск по пятибалльной шкале, пройдя по ссылке:
оценить выпуск >>

Вопрос № 169581: У меня 3 задачи - помогите решить!!! 1.Создать абстрактный базовый класс Employer (служащий) с чисто виртуальной функцией Print(). Создайте три производных класса: President, Manager, Worker. Переопределите функцию Print() для вывода информации, с...

Вопрос № 169583: Дана целочисленная прямоугольная матрица найти количество отрицательных элементов в тех строках в которых есть хотя бы один нулевой элемент!!! ОФОРМИТЬ ПОИСК СТРОК И ПОДСЧЕТ КОЛИЧЕСТВА ОТРИЦАТЕЛЬНЫХ ЭЛЕМЕНТОВ В ВИДЕ ВЫЗЫВАЕМОЙ ФУНКЦИИ!!!...
Вопрос № 169581:

У меня 3 задачи - помогите решить!!!
1.Создать абстрактный базовый класс Employer (служащий) с чисто виртуальной функцией Print(). Создайте три производных класса: President, Manager, Worker. Переопределите функцию Print() для вывода информации, соответствующей каждому типу служащего.

2.Создать базовый класс список. Реализовать на базе списка стек и очередь с виртуальными функциями вставки и вытаскивания.

3.Создать абстрактный базовый класс с виртуальной функцией - площадь. Создать производные классы: прямоугольник, круг, прямоугольный треугольник, трапеция со своими функциями площади. Для проверки определить массив ссылок на абстрактный класс, которым присваиваются адреса различных объектов. Площадь трапеции:S=(a+b)h/2
Заранее спасибо!!!

Отправлен: 18.06.2009, 21:24
Вопрос задал: Каминский Руслан Анатольевич, Посетитель
Всего ответов: 1
Страница вопроса >>

Отвечает Ross, Практикант :
Здравствуйте, Каминский Руслан Анатольевич.

1)
Код:
#include <iostream>
using namespace std;

class Employee
{
public:
    virtual void Print() = 0;

public:
    virtual ~Employee() = 0
    {}
};

class Worker : public Employee
{
public:

   void Print()
    {
        cout << "Worker" << endl;
    }
};

class Manager : public Employee
{
public:
    void Print()
    {
        cout << "Manager" << endl;
    }
};

class President : public Employee
{
public:
    void Print()
    {
        cout << "President" << endl;
    }
};

int main()
{
    Employee* e
 mployee;

    employee = new Worker();
    employee->Print();
    delete employee;

    employee = new Manager();
    employee->Print();
    delete employee;

    employee = new President();
    employee->Print();
    delete employee;
}


2) Список используется односвязный (было лень переписывать)
Код:
#include <iostream>
using namespace std;

//параметризованный однонаправленный список
template <typename T>
class List
{
private:
    //----single list node
    class node
    {
    public:
        T data;

        node* next;
    public:
        node(node *_next)
            :next(_next)
        {}
    };

private:

     class node *head, *tail;

public:
    void push_front(const T& val)
    {
        if (empty())
        {
            head = new node(tail);
            head->data = val;
        }
        else
        {
            head = new node(head);
            head->data = val;
        }
    }

public:
    void push_back(const T& val)
    {
        if (empty())
        {
            head = new node(tail);
            head->data = val;

       }
        else
        {
            node *srh_node = head;
            for (;srh_node->next != tail ; srh_node = srh_node->next)
                ;


            srh_node->next = new node(tail);
            srh_node->next->data = val;
        }
    }

public:
    T pop_front()
    {
        T val = head->data;
        node *to_del = head;
        head = head->next;

        delete to_
 del;
        return val;
    }

public:
    T pop_back()
    {
        node *srh_node = head;

        if (srh_node->next == tail)
        {
            head = tail;
            T val = srh_node->data;
            delete srh_node;

            return val;
        }
        else
        {
            for (; (srh_node->next->next != tail); srh_node = srh_node->next)
                ;

            T val = srh_node->next->data;

           node* to_del = srh_node->next;
            srh_node->next = srh_node->next->next;
            delete to_del;

            return val;
        }
    }

public:
    bool empty() const
    {
        return head == tail;
    }

public:
    virtual void clear()
    {
        node *dl_node;
        for (node *cr_node = head; cr_node != tail;)
        {
            dl_node = cr_node;
    
         cr_node = cr_node->next;

            delete dl_node;
        }

        head = tail;
    }

public:
    List()
    {
        head = tail = new node(0);
    }

public:
    List(const List& l)
    {
        clear();
        node *cur_node = head;

        for (node* srh_node = l.head;
            srh_node != l.tail; srh_node = shr_node->next)
        {
            cur_node->next = new node(tail);
            cur_node->data
= srh_node->data;
        }

    }

public:
    virtual ~List()
    {
        clear();
    }
};

template <typename Ty>
class Queue : protected List<Ty>
{
public:
    Queue()
        :List()
    {}

public:
    Queue(const Queue& rhs)
        :List(rhs)
    {}

public:
    ~Queue()
    {}

public:
    inline void push(const Ty& value)
    {
        List<T
 y>::push_back(value);
    }

public:
    inline Ty pop()
    {
        return List<Ty>::pop_front();
    }
};

template <typename Ty>
class Stack : protected List<Ty>
{
public:
    Stack()
        :List()
    {}

public:
    Stack(const Stack& rhs)
        :List(rhs)
    {}

public:
    ~Stack()
    {}

public:
    inline void push(const Ty& value)
    {
        List<Ty>::push_front(value);

   }

public:
    inline Ty pop()
    {
        return List<Ty>::pop_front();
    }
};

int main()
{
    Queue<int> qi;
    qi.push(1);    qi.push(2);    qi.push(3);

    cout << qi.pop() << endl;
    cout << qi.pop() << endl;
    cout << qi.pop() << endl;

    Stack<int> si;
    si.push(1);    si.push(2);    si.push(3);

    cout << si.pop() <&l
 t; endl;
    cout << si.pop() << endl;
    cout << si.pop() << endl;
}


3)
Код:
#include <iostream>
using namespace std;

class Shape
{
public:
    virtual double Square() = 0;

public:
    virtual ~Shape()
= 0
    {}
};

class Rectangle : public Shape
{
private:
    double _a, _b;

public:
    Rectangle()
        :_a(0.0), _b(0.0)
    {}

public:
    Rectangle(double a, double b)
        :_a(a), _b(b)
    {}

public:
    Rectangle(const Rectangle& rhs)
        :_a(rhs._a), _b(rhs._b)
    {}

public:
    double Square()
    {
        return _a * _b;
    }
};

class Circle : public 
 Shape
{
private:
    double _r;

public:
    Circle()
        :_r(0.0)
    {}

public:
    Circle(double r)
        :_r(r)
    {}

public:
    Circle(const Circle& rhs)
        :_r(rhs._r)
    {}

public:
    double Square()
    {
        static const double pi = 3.1415926;
        return pi * _r * _r;
    }
};

class RightTriangle : public Shape
{
private:
    double _a, _b;

public:
    RightTriangle()

       :_a(0.0), _b(0.0)
    {}

public:
    RightTriangle(double a, double b)
        :_a(a), _b(b)
    {}

public:
    RightTriangle(const RightTriangle& rhs)
        :_a(rhs._a), _b(rhs._b)
    {}

public:
    double Square()
    {
        return _a * _b / 2;
    }
};

class Trapezium : public Shape
{
private:
    double _a, _b, _h;

public:
    Trapezium()
    {}

public:
    Tr
 apezium(double a, double b, double h)
        :_a(a), _b(b), _h(h)
    {}

public:
    Trapezium(const Trapezium& rhs)
        :_a(rhs._a), _b(rhs._b), _h(rhs._h)
    {}

public:
    double Square()
    {
        return (_a + _b) * _h / 2;
    }
};

int main()
{
    Shape* shapes[4];
    shapes[0] = new Rectangle(2.0, 2.0);
    shapes[1] = new RightTriangle(2.0, 2.0);
    shapes[2] = new Circle(1.0);
    shapes[3] = new Trapezium(1.0, 2.0, 3.0);


   for (int i=0; i<4; ++i) {
        cout << shapes[i]->Square() << endl;
        delete shapes[i];
    }
};



-----
Good judgement comes from experience, and experience comes from bad judgement.

Ответ отправил: Ross, Практикант
Ответ отправлен: 19.06.2009, 01:49

Оценка ответа: 5
Комментарий к оценке:
ответ отличный! Все просто Доходчиво и понятно!

Как сказать этому эксперту "спасибо"?
  • Отправить SMS #thank 251175 на номер 1151 (Россия) | Еще номера >>
  • Отправить WebMoney:
    • Вам помогли? Пожалуйста, поблагодарите эксперта за это!

    Вопрос № 169583:

    Дана целочисленная прямоугольная матрица найти количество отрицательных элементов в тех строках в которых есть хотя бы один нулевой элемент!!! ОФОРМИТЬ ПОИСК СТРОК И ПОДСЧЕТ КОЛИЧЕСТВА ОТРИЦАТЕЛЬНЫХ ЭЛЕМЕНТОВ В ВИДЕ ВЫЗЫВАЕМОЙ ФУНКЦИИ!!!

    Отправлен: 18.06.2009, 21:50
    Вопрос задал: Durher, Посетитель
    Всего ответов: 1
    Страница вопроса >>

    Отвечает Micren, Практикант :
    Здравствуйте, Durher.
    Программа. С++.
    Код:

    #include <locale>
    #include <iostream>
    #include <iomanip>
    #include <cstdlib>
    #include <ctime>

    using namespace std;

    // Шаблонная функция которая подсчитывает количество нулевых и орицательных
элементов в строке
    // matrix - матрица
    // row - строка в которой будем считать
    // negatives -  количество отрицательных
    // Результат вызова функции - количество нулевых
    template<class T,size_t Dim1,size_t Dim2>
    size_t countZeroesAndNegatives(T (&matrix)[Dim1][Dim2],size_t row,size_t& negatives)
    {
     // Обнулим счетчики
     size_t zeroes=0;
     negatives=0;
     // Проверка корректности параметра row
     if(row<Dim1)
     {
      // Ид
 ем по строке
      for(size_t j=0;j<Dim2;++j)
      {
       // Считаем
       zeroes+=matrix[row][j]==0;
       negatives+=matrix[row][j]<0;
      }
     }
     return zeroes;
    }

    int main()
    {
     // Размерности матрицы
     const size_t ROWS=5,COLS=7;
     int matrix[ROWS][COLS];
     setlocale(LC_ALL,"russian");
     srand(static_cast<unsigned int>(time(0)));
     // Заполняем матрицу случайными числами и печатаем ее
     cout<<"Матрица:"<<endl;
     for(size_t i=0;i<ROWS;++i)
     {
      for(size_t
j=0;j<COLS;++j)
      {
       matrix[i][j]=static_cast<int>(static_cast<double>(rand())/RAND_MAX*21-10);
       cout<<setw(4)<<matrix[i][j]<<' ';
      }
      cout<<endl;
     }
     // Идем по строкам и проверяем их согласно условию
     for(size_t i=0;i<ROWS;++i)
     {
      size_t negatives;
      // Вывод будет только если функция вернет не ноль. Т.е. если будут нулевые элементы.
      count
 ZeroesAndNegatives(matrix,i,negatives) && cout<<"Строка "<<i<<" содержит "<<negatives<<" отрицательных элементов"<<endl;
     }
     system("PAUSE");
     return 0;
    }


    Пример работы:
    Код:

    Матрица:
    
 -3   -6    7    2   -1    9    5
      -3    6   -2    0    0   10    3
      -7   10    6   -3   -1   -5    0
       5   10    2   -1   -1    5   -5
      -4   -7   -7   -9   -5   -7   -2
    Строка 1 содержит 2 отрицательных элементов
    Строка 2 содержит 4 отрицательных элементов

    Ответ отправил: Micren, Практикант
    Ответ отправлен: 18.06.2009, 21:56

    Как сказать этому эксперту "спасибо"?
  • Отправить SMS #thank 251167 на номер 1151 (Россия) | Еще номера >>
  • Отправить WebMoney:
    • Вам помогли? Пожалуйста, поблагодарите эксперта за это!

    Нам очень важно Ваше мнение об этом выпуске рассылки. Вы можете оценить этот выпуск по пятибалльной шкале, пройдя по ссылке:
    оценить выпуск >>

    подать вопрос экспертам этой рассылки >>

    Скажите "спасибо" эксперту, который помог Вам!

    Отправьте СМС-сообщение с тестом #thank НОМЕР_ОТВЕТА
    на короткий номер 1151 (Россия)
    Номер ответа и конкретный текст СМС указан внизу каждого ответа.

    Полный список номеров >>

    * Стоимость одного СМС-сообщения от 7.15 руб. и зависит от оператора сотовой связи. (полный список тарифов)
    ** При ошибочном вводе номера ответа или текста #thank услуга считается оказанной, денежные средства не возвращаются.
    *** Сумма выплаты эксперту-автору ответа расчитывается из суммы перечислений на портал от биллинговой компании.

    © 2001-2009, Портал RFpro.ru, Россия
    Авторское право: ООО "Мастер-Эксперт Про"
    Автор: Калашников О.А. | Программирование: Гладенюк А.Г.
    Хостинг: Компания "Московский хостер"
    Версия системы: 2009.6.3 от 20.06.2009
    В избранное