Сделать пользовательский класс QueueWithPriority шаблонным классом

@Dassis · Регистрация: 11.09.2015

Author24 — интернет-сервис помощи студентам

программа работает с определенным типом данных, сказали сделать чтобы можно было работать с любым, а я не совсем понимаю как расставить правильно шаблоны

C++

typedef enum
{
    LOW,
    NORMAL,
    HIGH } ElementPriority;
 
/** QueueElement structure */
struct QueueElement
{
    /// Priority enum #ElementPriority
    ElementPriority priority;
    /// Element name
    ///  template <class T> 
    std::string name;
    /** Default constructor */
    QueueElement(std::string nm, ElementPriority prt);
    /** Alternate constructor */
    //QueueElement(char nm[], ElementPriority prt);
   // Overload < for sort. Desperated. */
   // friend bool operator<(const QueueElement &leftel, const QueueElement &rightel);
   // Overload << for iostream
   // friend std::ostream& operator<<( std::ostream &ostr, const QueueElement &L );
 
};
 
/// Container type for #QueueWithPriority
typedef std::list<QueueElement> cont;
/// Container iterator type for #QueueWithPriority
typedef cont::iterator It;
/// Container reverse iterator type for #QueueWithPriority
typedef cont::reverse_iterator rIt;
 
/** QueueWithPriority container for QueueElement */
///template <class T>
class QueueWithPriority
{
private:
    cont list;
public:
    /// Constructor
    QueueWithPriority(void);
    /// Desctructor
    ~QueueWithPriority(void);
    /// put #QueueElement
    void putElement(const QueueElement &element);
    /// put char name[] and #ElementPriority priority
    void putElement(const char nm[], ElementPriority prt);
    /// return first #QueueElement
    QueueElement getElement(void);
    /// accelerate - set all #QueueElement priority to HIGH and move afrer HIGH elements and before  NORMAL elements
    void accelerate(void);
    /// return #__queue size
    int size(void){
        return list.size();
    }
    /// for human print #QueueWithPriority
    void print_queue(void);
 
};
 
QueueElement::QueueElement(std::string nm, ElementPriority prt)
{
    name=nm;
    priority=prt;
}
 
/*QueueElement::QueueElement(char nm[], ElementPriority prt)
{
    name = std::string(nm),
    priority = prt;
}*/
 
bool operator<(const QueueElement &leftel, const QueueElement &rightel)
{
    return (leftel.priority < rightel.priority);
}
 
std::ostream& operator<<( std::ostream &ostr, const QueueElement &L )
{
    char *priority_name;
    switch (L.priority)
    {
    case LOW: priority_name = "LOW";
        break;
    case NORMAL: priority_name = "NORMAL";
        break;
    case HIGH: priority_name = "HIGH";
        break;
    default: priority_name = "None";
    }
 
    ostr << "Q("<< L.name << "," << priority_name << ")";
    return ostr;
}
 
/// Constructor
QueueWithPriority::QueueWithPriority()
{
 
}
/// Destructor
QueueWithPriority::~QueueWithPriority()
{
 
}
 
void QueueWithPriority::putElement(const QueueElement &element)
{
    It iter;
    int check;
    bool insert = false;
    if ((!list.empty()) & (element.priority != LOW))
    {
        for(iter=list.begin(); iter != list.end(); iter++)
        {
            check = iter->priority - element.priority;
            if (check == -1)
            {
                list.insert(iter, element);
                insert = true;
                break;
            }
        }
        if (!insert)
        {
            list.push_front(element);
        }
    } else {
        list.push_back(element);
    }
}
 
void QueueWithPriority::putElement(const char name[], ElementPriority priority)
{
    putElement(QueueElement(name, priority));
}
 
QueueElement QueueWithPriority::getElement()
{
    if (!list.empty())
    {
        QueueElement qe = list.front();
        list.pop_front();
        return qe;
    } else {
        std::cerr << "No more QueueElement in QueueWithPriority!"<< std::endl;
    }
 
}
 
void QueueWithPriority::accelerate()
{
    It iter1;
    It iter2;
    bool low = false;
 
    for(iter1=--list.end();; iter1--)
    {
        if (iter1->priority == LOW)
        {
            iter1->priority = HIGH;
            iter2 = iter1;
            low = true;
        }
        if ( iter1 == list.begin())
        {
            break;
        }
    }// END for
 
    if (low)
    {
        for (iter1 = list.begin(); iter1 != list.end(); iter1++)
        {
            if (iter1->priority == NORMAL)
            {
                list.splice(iter1, list, iter2, list.end());
                break;
            }// END IF
        }
    }// END IF is_low
} // END accelerate
 
void QueueWithPriority::print_queue()
{
    It iter;
    std::cout << "[";
    for(iter=list.begin(); iter != list.end();iter++)
    {
        std::cout<< *iter<< ",";
    }
    std::cout << "]" << std::endl;
}

@nmcf · 08.11.2016, 07:37

C++

template <class T>
class QueueWithPriority
{
private:
    std::list<T> list;
public:
    /// Constructor
    QueueWithPriority(void);
    /// Desctructor
    ~QueueWithPriority(void);
    /// put #QueueElement
    void putElement(const T &element);
    /// put char name[] and #ElementPriority priority
    void putElement(const char nm[], ElementPriority prt);
    /// return first #QueueElement
    T getElement(void);
    /// accelerate - set all #QueueElement priority to HIGH and move afrer HIGH elements and before  NORMAL elements
    void accelerate(void);
    /// return #__queue size
    int size(void){
        return list.size();
    }
    /// for human print #QueueWithPriority
    void print_queue(void);
};

@Dassis · 08.11.2016, 08:36 **[ТС]**

nmcf, если следовать вашему варианту то struct QueueElement полностью пропадает

Добавлено через 1 минуту
а как сделать шаблон в самой структуре QueueElement я пытался, но появлялись проблемы со списком

@nmcf · 08.11.2016, 09:26

C++

template <class T>
struct QueueElement
{
    ElementPriority priority;
    T name;
    QueueElement(T nm, ElementPriority prt);
};
 
template <class T>
QueueElement<T>::QueueElement(T nm, ElementPriority prt): name(nm), priority(prt) {}
 
template <class T>
class QueueWithPriority
{
private:
    std::list<T> list;
public:
    /// Constructor
    QueueWithPriority(void);
    /// Desctructor
    ~QueueWithPriority(void);
    /// put #QueueElement
    void putElement(const T &element);
    /// put char name[] and #ElementPriority priority
    void putElement(const char nm[], ElementPriority prt);
    /// return first #QueueElement
    T getElement(void);
    /// accelerate - set all #QueueElement priority to HIGH and move afrer HIGH elements and before  NORMAL elements
    void accelerate(void);
    /// return #__queue size
    int size(void){
        return list.size();
    }
    /// for human print #QueueWithPriority
    void print_queue(void);
};
 
//...
 
QueueWithPriority<QueueElement<std::string>> q;

@Dassis · 09.11.2016, 19:47 **[ТС]**

nmcf, а можете подсказать, если я ставлю

C++

1	template <typename t>

перед функцией которая вызывается из

C++

main()

появляется ошибка "no matching function for call to...", что делать в этом случае?

@nmcf · 09.11.2016, 20:12

Как это выглядит?

@Dassis · 09.11.2016, 20:14 **[ТС]**

C++

#include <iostream>
#include <list>
#include <iterator>
#include <string>
 
typedef enum
{
  LOW,
  NORMAL,
  HIGH
} ElementPriority;
 
template <typename t>
struct QueueElement
{
  ElementPriority priority;
  t name;
  QueueElement(t nm, ElementPriority prt);
};
 
/*typedef std::list<QueueElement> cont;
typedef cont::iterator It;
typedef cont::reverse_iterator rIt;
*/
 
template <typename t>
class QueueWithPriority
{
private:
  std::list<t> list;
public:
  QueueWithPriority(void);
  ~QueueWithPriority(void);
  void putElement(const QueueElement<t> &element);
  QueueElement<t> getElement(void);
  void accelerate(void);
  void printQueue(void);
  int size(void)
  {
    return list.size();
  }
};
 
template <typename t>
QueueElement<t>::QueueElement(t nm, ElementPriority prt)
 
{
  name=nm;
  priority=prt;
}
template <typename t>
bool operator<(const QueueElement<t> &leftel, const QueueElement<t> &rightel)
{
  return (leftel.priority < rightel.priority);
}
 
template <typename t>
std::ostream& operator<<( std::ostream &ostr, const QueueElement<t> &P )
{
  const char *priority_name;
  switch (P.priority)
    {
    case LOW: priority_name = "LOW";
      break;
    case NORMAL: priority_name = "NORMAL";
      break;
    case HIGH: priority_name = "HIGH";
      break;
    default: priority_name = "None";
    }
  ostr << "[" << P.name << "," << priority_name << "]";
  return ostr;
}
 
template <typename t>
QueueWithPriority<t>::QueueWithPriority()
{
 
}
 
template <typename t>
QueueWithPriority<t>::~QueueWithPriority()
{
 
}
 
template <typename t>
void QueueWithPriority<t>::putElement(const QueueElement<t> &element)
{
  typename std::list<t>::iterator iter;
  int check;
  bool insert = false;
  if ((!list.empty()) & (element.priority != LOW))
    {
      for(iter=list.begin(); iter != list.end(); iter++)
        {
          check = iter->priority - element.priority;
          if (check == -1)
            {
              list.insert(iter, element);
              insert = true;
              break;
            }
        }
      if (!insert)
        {
          list.push_front(element);
        }
    } else {
      list.push_back(element);
    }
}
 
template <typename t>
QueueElement<t> QueueWithPriority<t>::getElement()
{
  if (!list.empty())
    {
      QueueElement<t> qe = list.front();
      list.pop_front();
      return qe;
    }
  else
    {
      std::cerr << "EMPTY"<< std::endl;
      exit(2);
    }
}
 
 
template <typename t>
void QueueWithPriority<t>::accelerate()
{
    typename std::list<t>::iterator iter1;
    typename std::list<t>::iterator iter2;
    /*list::iterator iter1;
    list::iterator iter2;*/
    bool is_low = false;
    for(iter1=--list.end();; iter1--)
    {
        if (iter1->priority == LOW)
        {
            iter1->priority = HIGH;
            iter2 = iter1;
            is_low = true;
        }
        if ( iter1 == list.begin())
        {
            break;
        }
    }
    if (is_low)
    {
        for (iter1 = list.begin(); iter1 != list.end(); iter1++)
        {
            if (iter1->priority == NORMAL)
            {
                list.splice(iter1, list, iter2, list.end());
                break;
            }
        }
    }
}
 
template <typename t>
void QueueWithPriority<t>::printQueue()
{
  typename std::list<t>::iterator iter;
  for(iter=list.begin(); iter != list.end();iter++)
    {
      std::cout<< *iter<< " ";
    }
  std::cout  << std::endl;
}
void printList(std::list<int> l)
{
  std::list<int>::iterator iter;
  for (iter=l.begin(); iter != l.end(); ++iter)
    {
      std::cout << *iter << " ";
    }
  std::cout << '\n';
}
 
void printListForm(std::list<int> l)
{
  std::list<int>::iterator iter1 = l.begin();
  std::list<int>::reverse_iterator iter2  = l.rbegin();
  for (size_t i = 0; i != l.size()/2; ++i, ++iter1, ++iter2)
    {
      std::cout << *iter1 << ' ';
      std::cout << *iter2 << ' ';
    }
  std::cout << '\n';
}
 
void input(std::list<int> &l)
{
  int tmp = 0;
  while(std::cin >> tmp)
    {
      try
      {
        if (tmp > 20 || tmp < 0)
          {
            throw 1;
          }
      }
      catch(int i)
      {
        std::cerr << "!!error input!!\n";
        exit(i);
      }
      l.push_back(tmp);
    }
}
 
template <class t> //???
void head(const int argc, const char *argv[])
{
  if (argc >= 1)
    {
      QueueWithPriority<t> queue;
      switch (argv[1][0])
        {
        case '1':
          {
            while(!std::cin.eof())
              {
                std::string command;
                std::cin >> command;
                if(command == "add")
                  {
                    std::string tmp1;
                    std::string tmp2;
                    ElementPriority priority;
                    std::cin >> tmp1;
                    std::cin >> tmp2;
                    if(tmp1 == "low")
                      {
                        priority = LOW;
                      }
                    if(tmp1 == "normal")
                      {
                        priority = NORMAL;
                      }
                    if(tmp1 == "high")
                      {
                        priority = HIGH;
                      }
                    if((tmp1 !=  "low") && (tmp1 != "normal") && (tmp1 != "high"))
                      {
                        std::cout << "INVALID COMMAND\n";
                        continue;
                      }
                    queue.putElement(QueueElement<t>(tmp2, priority));
                  }
                if (command == "get")
                  {
                    std::cout << queue.getElement() << std::endl;
                  }
                if (command == "accelerate")
                  {
                    queue.accelerate();
                  }
                if ((command != "accelerate") && (command != "get") && (command != "add"))
                  {
                    std::cerr << "INVALID COMMAND\n";
                    continue;
                  }
              }
          }
        case '2':
          {
            std::list<int> list;
            input(list);
            printList(list);
            std::cout << std::endl;
            printListForm(list);
          }
        }
    }
  else
    {
      std::cout << "!!invalid arguments!!!";
    }
}
 
 
int main (int argc, const char* argv[])
{
  head(argc, argv); //тут ошибка
  return 0;
}

Добавлено через 22 секунды
в низу кода отмеченно

@nmcf · 09.11.2016, 20:59

А зачем ты к head прикрутил template? В каком месте у тебя определяется тип элемента очереди?

@Dassis · 09.11.2016, 21:18 **[ТС]**

nmcf, в head используется

C++

1	QueueWithPriority<t> queue;

и

C++

1	QueueElement<t>(tmp2, priority)

Добавлено через 14 минут
а тип очереди определяется при вводе с консоли или из файла

@nmcf · 09.11.2016, 21:20

Это понятно. Где по логике программы определяется тип? Где-то он должен быть указан явно, чтобы шаблон заработал. Если в этой функции, то вместо t подставляй тип.

Добавлено через 50 секунд

Сообщение от Dassis

тип очереди определяется при вводе с консоли или из файла

Так не будет работать, тип должен быть определён явно на этапе компиляции.

@Dassis · 09.11.2016, 22:55 **[ТС]**

ставлю std::string вылетают итераторы

@nmcf · 09.11.2016, 23:29

Актуальный вариант покажи.

@Dassis · 09.11.2016, 23:41 **[ТС]**

C++

#include <iostream>
#include <list>
#include <iterator>
#include <string>
 
typedef enum
{
  LOW,
  NORMAL,
  HIGH
} ElementPriority;
 
struct QueueElement
{
  ElementPriority priority;
  std::string name;
  QueueElement(std::string nm, ElementPriority prt);
};
 
typedef std::list<QueueElement> cont;
typedef cont::iterator It;
typedef cont::reverse_iterator rIt;
 
 
class QueueWithPriority
{
private:
  cont list;
public:
  QueueWithPriority(void);
  ~QueueWithPriority(void);
  void putElement(const QueueElement &element);
  QueueElement getElement(void);
  void accelerate(void);
  void printQueue(void);
  int size(void)
  {
    return list.size();
  }
};
 
QueueElement::QueueElement(std::string nm, ElementPriority prt)
 
{
  name=nm;
  priority=prt;
}
 
 
bool operator<(const QueueElement &leftel, const QueueElement &rightel)
{
  return (leftel.priority < rightel.priority);
}
 
std::ostream& operator<<( std::ostream &ostr, const QueueElement &P )
{
  const char *priority_name;
  switch (P.priority)
    {
    case LOW: priority_name = "LOW";
      break;
    case NORMAL: priority_name = "NORMAL";
      break;
    case HIGH: priority_name = "HIGH";
      break;
    default: priority_name = "None";
    }
  ostr << "[" << P.name << "," << priority_name << "]";
  return ostr;
}
 
QueueWithPriority::QueueWithPriority()
{
 
}
 
QueueWithPriority::~QueueWithPriority()
{
 
}
 
void QueueWithPriority::putElement(const QueueElement &element)
{
  It iter;
  int check;
  bool insert = false;
  if ((!list.empty()) & (element.priority != LOW))
    {
      for(iter=list.begin(); iter != list.end(); iter++)
        {
          check = iter->priority - element.priority;
          if (check == -1)
            {
              list.insert(iter, element);
              insert = true;
              break;
            }
        }
      if (!insert)
        {
          list.push_front(element);
        }
    } else {
      list.push_back(element);
    }
}
 
QueueElement QueueWithPriority::getElement()
{
  if (!list.empty())
    {
      QueueElement qe = list.front();
      list.pop_front();
      return qe;
    }
  else
    {
      std::cerr << "EMPTY"<< std::endl;
      exit(2);
    }
}
 
void QueueWithPriority::accelerate()
{
    It iter1;
    It iter2;
    bool is_low = false;
    for(iter1=--list.end();; iter1--)
    {
        if (iter1->priority == LOW)
        {
            iter1->priority = HIGH;
            iter2 = iter1;
            is_low = true;
        }
        if ( iter1 == list.begin())
        {
            break;
        }
    }
    if (is_low)
    {
        for (iter1 = list.begin(); iter1 != list.end(); iter1++)
        {
            if (iter1->priority == NORMAL)
            {
                list.splice(iter1, list, iter2, list.end());
                break;
            }
        }
    }
}
 
void QueueWithPriority::printQueue()
{
  It iter;
  for(iter=list.begin(); iter != list.end();iter++)
    {
      std::cout<< *iter<< " ";
    }
  std::cout  << std::endl;
}
void printList(std::list<int> l)
{
  std::list<int>::iterator iter;
  for (iter=l.begin(); iter != l.end(); ++iter)
    {
      std::cout << *iter << " ";
    }
  std::cout << '\n';
}
 
void printListForm(std::list<int> l)
{
  std::list<int>::iterator iter1 = l.begin();
  std::list<int>::reverse_iterator iter2  = l.rbegin();
  for (size_t i = 0; i != l.size()/2; ++i, ++iter1, ++iter2)
    {
      std::cout << *iter1 << ' ';
      std::cout << *iter2 << ' ';
    }
  std::cout << '\n';
}
 
void input(std::list<int> &l)
{
  int tmp = 0;
  while(std::cin >> tmp)
    {
      try
      {
        if (tmp > 20 || tmp < 0)
          {
            throw 1;
          }
      }
      catch(int i)
      {
        std::cerr << "!!error input!!\n";
        exit(i);
      }
      l.push_back(tmp);
    }
}
 
void head(const int argc, const char* argv[])
{
  if (argc >= 1)
    {
      QueueWithPriority queue;
      switch (argv[1][0])
        {
        case '1':
          {
            while(!std::cin.eof())
              {
                std::string command;
                std::cin >> command;
                if(command == "add")
                  {
                    std::string tmp1;
                    std::string tmp2;
                    ElementPriority priority;
                    std::cin >> tmp1;
                    std::cin >> tmp2;
                    if(tmp1 == "low")
                      {
                        priority = LOW;
                      }
                    if(tmp1 == "normal")
                      {
                        priority = NORMAL;
                      }
                    if(tmp1 == "high")
                      {
                        priority = HIGH;
                      }
                    if((tmp1 !=  "low") && (tmp1 != "normal") && (tmp1 != "high"))
                      {
                        std::cout << "INVALID COMMAND\n";
                        continue;
                      }
                    queue.putElement(QueueElement(tmp2, priority));
                  }
                if (command == "get")
                  {
                    std::cout << queue.getElement() << std::endl;
                  }
                if (command == "accelerate")
                  {
                    queue.accelerate();
                  }
                if ((command != "accelerate") && (command != "get") && (command != "add"))
                  {
                    std::cerr << "INVALID COMMAND\n";
                    continue;
                  }
              }
          }
        case '2':
          {
            std::list<int> list;
            input(list);
            printList(list);
            std::cout << std::endl;
            printListForm(list);
          }
        }
    }
  else
    {
      std::cout << "!!invalid arguments!!!";
    }
}
 
int main (const int argc, const char* argv[])
{
  head(argc, argv);
}

Добавлено через 3 минуты
nmcf,

C++

1
2
3

typedef std::list<QueueElement> cont;
typedef cont::iterator It;
typedef cont::reverse_iterator rIt;

, на мой взгляд перестаёт работать из-за этого, а как совмещать

C++

typedef

и

C++

template

я не знаю

@nmcf · 10.11.2016, 00:01

Ну не используй typedef. Запиши развёрнуто.

@Dassis · 10.11.2016, 00:03 **[ТС]**

nmcf, как?

@Dassis 0 / 0 / 1 Регистрация: 11.09.2015 Сообщений: 83
	08.11.2016, 08:36 [ТС]	3
	nmcf, если следовать вашему варианту то struct QueueElement полностью пропадает Добавлено через 1 минуту а как сделать шаблон в самой структуре QueueElement я пытался, но появлялись проблемы со списком 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,671
	09.11.2016, 20:12	6
	Как это выглядит? 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,671
	09.11.2016, 20:59	8
	А зачем ты к head прикрутил template? В каком месте у тебя определяется тип элемента очереди? 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,671
	09.11.2016, 21:20	10
	Это понятно. Где по логике программы определяется тип? Где-то он должен быть указан явно, чтобы шаблон заработал. Если в этой функции, то вместо t подставляй тип. Добавлено через 50 секунд Сообщение от Dassis тип очереди определяется при вводе с консоли или из файла Так не будет работать, тип должен быть определён явно на этапе компиляции. 0

@Dassis 0 / 0 / 1 Регистрация: 11.09.2015 Сообщений: 83
	09.11.2016, 22:55 [ТС]	11
	ставлю std::string вылетают итераторы 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,671
	09.11.2016, 23:29	12
	Актуальный вариант покажи. 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,671
	10.11.2016, 00:01	14
	Ну не используй typedef. Запиши развёрнуто. 1

@Dassis 0 / 0 / 1 Регистрация: 11.09.2015 Сообщений: 83
	10.11.2016, 00:03 [ТС]	15
	nmcf, как? 0