聊天室是一种典型的网络应用，这个程序演示了ICE框架的基本结构。

启动Server命令行

chatserver --Ice.Config=config.chatserver

带路由的client启动命令如下：

glacier2router --Ice.Config=/QTOA/ChatDemo-1.4.0/config/nfig.glacier2router

./chatgl2client --Ice.Config=/QTOA/ChatDemo-1.4.0/config/config.chatgl2client

不带路由的Poll方式启动client命令如下：

./chatpollclient --Ice.Config=/QTOA/ChatDemo-1.4.0/config/config.chatpollclient

1）定义SLICE接口。

module Chat {

interface MessageReceiver {
    void onMessage(string sender, string msg);
};

dictionary<string, MessageReceiver*> UserList;
 
interface Room {
    bool login(string user, MessageReceiver* receiver);
    void logout(string user);
    void sendMessage(string user, string message);
};

};

定义两个接口，Room用于服务器端实现，MessageReceiver用于客户端实现。
使用slice2cpp生成C++文件: chat.h, chat.cpp.

2）服务器端实现。

#include <iostream>
#include <Ice/Ice.h>
#include "chat.h"

using std::string;

class ChatRoomI : public Chat::Room {
public:
    virtual bool login(const string&, const Chat::MessageReceiverPrx&, const Ice::Current&);
    virtual void logout(const string&, const Ice::Current&);
    virtual void sendMessage(const string&, const string&, const Ice::Current&);
private:
    void broadcast(const string& user, const string& message);
    bool notify(const Chat::MessageReceiverPrx& receiver, const string& sender, const string& message);
    
    Chat::UserList    users_;
};

bool ChatRoomI::login(const string& user, const Chat::MessageReceiverPrx& receiver, const Ice::Current&) {
    if (users_.find(user) != users_.end()) {
        return false;
    }
    users_.insert(Chat::UserList::value_type(user, receiver));
    broadcast(user, "---login---");
    return true;
}

void ChatRoomI::logout(const string& user, const Ice::Current&) {
    users_.erase(user);
    broadcast(user, "===logout===");
}

void ChatRoomI::sendMessage(const string& user, const string& message, const Ice::Current&) {
    broadcast(user, message);
}

void ChatRoomI::broadcast(const string& user, const string& message) {
    Chat::UserList::iterator it = users_.begin(), end = users_.end();
    while (it != end) {
        if (user != it->first && !notify(it->second, it->first, message))
            users_.erase(it++);
        else
            ++it;
    }
}

bool ChatRoomI::notify(const Chat::MessageReceiverPrx& receiver, const string& sender, const string& message) {
    bool ret = true;    
    try {
        receiver->onMessage(sender, message);
    } catch(const std::exception& ex) {
        ret = false;
    }
    return ret;
}

class Server : public Ice::Application {
public:
    virtual int run(int argc, char* argv[]) {
        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapterWithEndpoints(
                "Chat.RoomAdapter", "default -p 10000");
        Chat::RoomPtr room = new ChatRoomI;
        adapter->add(room, communicator()->stringToIdentity("Chat.Room"));
        adapter->activate();
        communicator()->waitForShutdown();
        return 0;
    }
};

int main(int argc, char* argv[]) {
    Server app;
    return app.main(argc, argv);
}

3）客户端实现。

#include <iostream>
#include <Ice/Ice.h>
#include "chat.h"

using std::string;

class ChatUserI : public Chat::MessageReceiver {
public:
    virtual void onMessage(const string& user, const string& message, const Ice::Current&) {
        std::cout << user << " :  " << message << std::endl;
    }
};

class Client : public Ice::Application {
public:
    virtual int run(int argc, char* argv[]) {
        Chat::RoomPrx chatRoom = Chat::RoomPrx::checkedCast(
                communicator()->stringToProxy("Chat.Room:default -p 10000"));
        if (!chatRoom)  {
            std::cout << "Proxy not existed!/n";
            return -1;
        }
    
        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapterWithEndpoints(
                "Chat.UserAdapter", "default");
        Chat::MessageReceiverPtr user = new ChatUserI;
        adapter->add(user, communicator()->stringToIdentity("Chat.User"));
        adapter->activate();
        
        Chat::MessageReceiverPrx userPrx = Chat::MessageReceiverPrx::uncheckedCast(
                adapter->createProxy(communicator()->stringToIdentity("Chat.User")));
        
        string name;
        std::cout << "Please input user name: ";
        std::cin >> name;
        if (!chatRoom->login(name, userPrx)) {
            std::cout << "login error: User Name already exist!/n";
            return 0;
        }
        std::cout << "login OK!" << std::endl;
        
        string message;
        while (std::getline(std::cin, message) && message != "quit") {
            chatRoom->sendMessage(name, message);
        }

        chatRoom->logout(name);

        return 0;
    }
};

int main(int argc, char* argv[]) {
    Client app;
    return app.main(argc, argv);
}