Developing.ru

Код: Выделить всё

#ifndef QUEUE_H
#define QUEUE_H

// Message structure
struct queueNodeStruct {
  char to[128];
  char message[512];
  struct queueNodeStruct *nextPtr;
};

typedef struct queueNodeStruct queueNode;
typedef queueNode *queueNodePtr;



// Queue class
class queueClass {
  private:
    queueNodePtr headPtr;
    queueNodePtr tailPtr;

  public:
    queueClass( );
    int isEmpty( queueNodePtr );
    void dequeue( );
    void enqueue( char [], char []);
    queueNodePtr queueHead( );
    queueNodePtr queueTail( );
};


// Constructor
queueClass::queueClass( ) {

  headPtr = NULL;
  tailPtr = NULL;
}


// Queue is empty?
int queueClass::isEmpty( queueNodePtr headPtr ) {

  return headPtr == NULL;
}


// Enqueue -- add message to queue
void queueClass::enqueue( char to[], char msg[]) {
  queueNodePtr newPtr;

  newPtr = new queueNode;
  if( newPtr != NULL ) {
    strncpy( newPtr->to, to, 128 );
    strncpy( newPtr->message, msg, 512 );
    newPtr->nextPtr = NULL;
    if( isEmpty( headPtr ) ) {
      headPtr = newPtr;
    }
    else {
      tailPtr->nextPtr = newPtr;
    }
    tailPtr = newPtr;
  }
  else {
    std::cout << "Cannot allocate memory in queue for new item.\n";
  }
}


// Dequeue -- remove message from queue
void queueClass::dequeue( ) {
  queueNodePtr nodeToDel;

  if( !isEmpty( headPtr ) ) {
    nodeToDel = headPtr;
    headPtr = headPtr->nextPtr;
    if( headPtr == NULL ) {
      tailPtr = NULL;
    }
    delete nodeToDel;
  }
}


// Get head pointer
queueNodePtr queueClass::queueHead( ) {

  return headPtr;
}


// Get tail pointer
queueNodePtr queueClass::queueTail( ) {

  return tailPtr;
}

#endif

Код: Выделить всё

#include <iostream>
#include "queue.h"

void instructions( void );
void printQueue( queueNodePtr currentNode );


int main() {
  queueClass queue;
  int choice;
  char to[128], msg[512];


  instructions();
  std::cout << "? ";
  std::cin  >> choice;

  while( choice != 3 ) {
    switch( choice ) {
      case 1:
        std::cout << "Message to: ";
        std::cin  >> to;
        std::cout << "Message: ";
        std::cin  >> msg;
        queue.enqueue( to, msg );
        printQueue( queue.queueHead() );
        break;

      case 2:
        queue.dequeue( );
        printQueue( queue.queueHead() );
        break;

      default:
        std::cout << "Invalid choice\n";
        instructions();
        break;
    }

    std::cout << "? ";
    std::cin  >> choice;
  }

  std::cout << "End of run.\n";
  return 0;
}


void instructions( void ) {

  std::cout << "Your choice:\n" << "  1. add item\n" << "  2. remove item\n" << "  3. quit\n";
}


void printQueue( queueNodePtr currentPtr ) {

  if( currentPtr == NULL ) {
    std::cout << "Queue is empty" << std::endl;
  }
  else {
    std::cout << "The queue is:" << std::endl;
    while( currentPtr != NULL ) {
      std::cout << currentPtr->to << " -> [" << currentPtr->message << "]" << std::endl;
      currentPtr = currentPtr->nextPtr;
    }
  }
}