Messages Order

Sort by

recency

|

93 Discussions

|

  • + 0 comments

    Message's id assignment should be handled by the factory.

    class Message {
    public: 
        Message() {}
        Message(string text, int id):msg_body(text), msg_id(id) {}
        const string& get_text() {
            return msg_body;
        }
        bool operator<(const Message& other) const {
            return this->msg_id < other.msg_id;
        }
        
    private:
        string msg_body;
        int msg_id;
    };
    
    class MessageFactory {
    public:
        MessageFactory() {}
        Message create_message(const string& text) {
            msg_counter += 1;
            return Message(text, msg_counter);
        }
    private:
        int msg_counter = -1;
    };
    
  • + 0 comments
    class Message {
    private:
        string text;
        static int id;
        int current_id;
    public:
        Message() { current_id = ++id; }
        Message(string t){ current_id = ++id; text=t; }
        const string& get_text() {
            return text;
        }
        bool operator < (const Message& M2) {
            if(current_id < M2.current_id)
                return true;
            else
                return false;
        }
    };
    int Message::id = 0;
    class MessageFactory {
    public:
        MessageFactory() {}
        Message create_message(const string& text) {
            Message m = Message(text);
            return m;
        }
    };
    
  • + 0 comments

    The key is the static variable.

  • + 0 comments
    class Message {
    public: 
        Message() {}
        
        Message (const string& m) : m_Id(s_Id++), m_Message(m) {}
        
        const string& get_text() {
            return m_Message;
        }
        
        bool operator<(const Message& toCompare)
        {
            return m_Id < toCompare.m_Id;
        }
        
        static int s_Id;
        private:
        int m_Id;
        string m_Message;
        
    };
    
    int Message::s_Id = 0;
    
    class MessageFactory {
    public:
        MessageFactory() {}
        Message create_message(const string& text) {
            return Message(text);
        }
    };``
    
  • + 0 comments

    use c++ version 2014 otherwise not work

    #include <iostream>
    #include <algorithm>
    #include <vector>
    
    using namespace std;
    
    class Message {
        string message;
        int order;
        static int tot_n;
    public: 
        Message(){ 
            tot_n++;
            order = tot_n;
        }
        Message(const string& s){
            tot_n++;
            order = tot_n;
            message = s;
        }
        const string& get_text() {
            return message;
        }
        bool operator<(const Message& m){
            return (order < m.order);
        }
    };
    
    int Message::tot_n = 0;
    
    class MessageFactory {
    public:
        MessageFactory() {}
        Message create_message(const string& text) {
            Message m(text);
            return m;
        }
    };
    
    class Recipient {
    public:
        Recipient() {}
        void receive(const Message& msg) {
            messages_.push_back(msg);
        }
        void print_messages() {
            fix_order();
            for (auto& msg : messages_) {
                cout << msg.get_text() << endl;
            }
            messages_.clear();
        }
    private:
        void fix_order() {
            sort(messages_.begin(), messages_.end());
        }
        vector<Message> messages_;
    };
    
    class Network {
    public:
        static void send_messages(vector<Message> messages, Recipient& recipient) {
        // simulates the unpredictable network, where sent messages might arrive in unspecified order
            random_shuffle(messages.begin(), messages.end());         
            for (auto msg : messages) {
                recipient.receive(msg);
            }
        }
    };
    
    
    
    int main() {
        MessageFactory message_factory;
        Recipient recipient;
        vector<Message> messages;
        string text;
        while (getline(cin, text)) {
            messages.push_back(message_factory.create_message(text));
        }
        Network::send_messages(messages, recipient);
        recipient.print_messages();
    }