de java vers c++

de java vers c++ - C++ - Programmation

Marsh Posté le 07-03-2006 à 09:53:11    

J'ai fait une application client serveur en utilisant ICE. Je l'ai ecrite en Java.
Jusque la pas de problemes.
 
Maintenant, il faut que je fasse la meme chose en C++. Le probleme est que je n'ai pas tres bonnes connaissances dans ce langage.
J'ai ecrit le serveur, mais il y a des erreurs de compilation. Je n'arrive pas a les corriger. J'utilise VC++6.
 
Je met les sources en java , puis celles en c++
 
Pour le java, tout va bien.  
 
Pouvez me dire ce qui ne va pas dans mon prog en c++
 
Java
 

Code :
  1. //Hello.ice
  2. module Demo {
  4. sequence<double> array; //new type : array is an array of double
  6. class Transmit {
  7.  int a;
  8.  array arr ;//array of double
  9. };
  11. interface Hello {
  12.  nonmutating void sayHello(string s);
  13.  Transmit setClass(int a, double d1, double d2, double d3);
  14.  void sendClass(Transmit trans);
  15. };
  18. };


 

Code :
  1. import Demo.*;
  2. import java.io.*;
  4. class HelloI extends Demo._HelloDisp {
  7. public void sayHello(String s, Ice.Current current) {
  8.  System.out.println(s);
  9. }
  12. public Transmit setClass(int a, double d1, double d2, double d3, Ice.Current current) {
  14.  double arr[] = new double[3];
  15.  arr[0] = d1;
  16.  arr[1] = d2;
  17.  arr[2] = d3;
  19.  Transmit trans = new Transmit(a, arr);
  21.  return trans;
  23. }
  25. public void sendClass(Transmit trans,Ice.Current current) {
  27.  double arr[] = {0, 0, 0};
  28.  Transmit trans_serv = new Transmit(0, arr);
  29.  trans_serv.a = trans.a;
  30.  for (int i = 0; i < trans.arr.length; i++) trans_serv.arr[i] = trans.arr[i];
  32. }
  33. }
  36. public class Server  {
  37. public static void main (String []args) {
  38.  int status = 0;
  39.  Ice.Communicator ic = null;
  40.  try {
  41.        ic = Ice.Util.initialize(args);
  42.    Ice.ObjectAdapter adapter = ic.createObjectAdapterWithEndpoints("SimpleHelloAdapter", "default -p 11111" );
  43.   Ice.Object object = new HelloI();
  44.   adapter.add(object, Ice.Util.stringToIdentity("SimpleHello" ));
  45.   adapter.activate();
  46.   ic.waitForShutdown();
  47.  } catch (Ice.LocalException e) {
  48.      e.printStackTrace();
  49.      status = 1;
  50.  } catch (Exception e) {
  51.      System.err.println(e.getMessage());
  52.      status = 1;
  53.  }
  54.  if(ic != null) {
  55.     try {
  56.     ic.destroy();
  57.     } catch (Exception e) {
  58.   System.out.println(e.getMessage());
  59.   status = 1;
  60.     }
  61.  }
  62. System.exit(status);
  63. }  //main
  64. } // Server


 
 
C++
 

Code :
  1. // **********************************************************************
  2. //
  3. // Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
  4. //
  5. // This copy of Ice is licensed to you under the terms described in the
  6. // ICE_LICENSE file included in this distribution.
  7. //
  8. // **********************************************************************
  10. #ifndef HELLO_I_H
  11. #define HELLO_I_H
  13. #include <Hello.h>
  15. using namespace Demo;
  16. using namespace std;
  18. class HelloI : public Demo::Hello
  19. {
  20. public:
  22.     void sayHello(const string& s, const Ice::Current& );
  23. Transmit setClass(const int a, double d1, double d2, double d3, const Ice::Current& );
  24. void sendClass(Transmit trans, const Ice::Current& );
  25. };
  27. #endif


 

Code :
  1. // **********************************************************************
  2. //
  3. // Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
  4. //
  5. // This copy of Ice is licensed to you under the terms described in the
  6. // ICE_LICENSE file included in this distribution.
  7. //
  8. // **********************************************************************
  10. #include <HelloI.h>
  11. #include <Ice/Ice.h>
  13. using namespace std;
  15. void
  16. HelloI::sayHello(const string& s, const Ice::Current& )
  17. {
  18.     cout << s << endl;
  19. }
  21. Transmit
  22. HelloI::setClass(const int a, double d1, double d2, double d3, const Ice::Current & )
  23. {
  24. Transmit trans ;
  26. trans.a = a;
  27. trans.arr[0] = d1;
  28. trans.arr[1] = d2;
  29. trans.arr[2] = d3;
  31. cout << "dans setClass" << endl;
  32. //Transmit trans = new trans (a, arr);
  33. cout << trans.a << endl;
  34. return (trans);
  35. }
  37. void
  38. HelloI::sendClass(Transmit trans, const Ice::Current& )
  39. {
  40. Transmit new_trans ;
  41. new_trans.a = trans.a;
  42. for (int i = 0; i < 3; i++) new_trans.arr[i] = trans.arr[i];
  43. }


 

Code :
  1. // **********************************************************************
  2. //
  3. // Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
  4. //
  5. // This copy of Ice is licensed to you under the terms described in the
  6. // ICE_LICENSE file included in this distribution.
  7. //
  8. // **********************************************************************
  10. #include <HelloI.h>
  11. #include <Ice/Ice.h>
  13. using namespace std;
  14. using namespace Demo;
  16. int
  17. main(int argc, char* argv[])
  18. {
  19.     int status = EXIT_SUCCESS;
  20.     Ice::CommunicatorPtr communicator;
  22.     try
  23.     {
  24. communicator = Ice::initialize(argc, argv);
  25. Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SimpleHelloAdapter", "tcp -p 10000" );
  26. Ice::ObjectPtr object = new HelloI;
  27. adapter->add(object, Ice::stringToIdentity("SimpleHello" ));
  28. adapter->activate();
  29. communicator->waitForShutdown();
  30.     }
  31.     catch(const Ice::Exception& ex)
  32.     {
  33. cerr << ex << endl;
  34. status = EXIT_FAILURE;
  35.     }
  37.     if(communicator)
  38.     {
  39. try
  40. {
  41.     communicator->destroy();
  42. }
  43. catch(const Ice::Exception& ex)
  44. {
  45.     cerr << ex << endl;
  46.     status = EXIT_FAILURE;
  47. }
  48.     }
  50.     return status;
  51. }


 
 
les fichiers hello.h et hello.cpp sont generes automatiquement

Code :
  1. // **********************************************************************
  2. //
  3. // Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
  4. //
  5. // This copy of Ice is licensed to you under the terms described in the
  6. // ICE_LICENSE file included in this distribution.
  7. //
  8. // **********************************************************************
  10. // Ice version 3.0.1
  11. // Generated from file `Hello.ice'
  13. #ifndef __Hello_h__
  14. #define __Hello_h__
  16. #include <Ice/LocalObjectF.h>
  17. #include <Ice/ProxyF.h>
  18. #include <Ice/ObjectF.h>
  19. #include <Ice/Exception.h>
  20. #include <Ice/LocalObject.h>
  21. #include <Ice/Proxy.h>
  22. #include <Ice/Object.h>
  23. #include <Ice/Outgoing.h>
  24. #include <Ice/Incoming.h>
  25. #include <Ice/Direct.h>
  26. #include <Ice/FactoryTable.h>
  27. #include <Ice/StreamF.h>
  28. #include <Ice/UndefSysMacros.h>
  30. #ifndef ICE_IGNORE_VERSION
  31. #   if ICE_INT_VERSION / 100 != 300
  32. #       error Ice version mismatch!
  33. #   endif
  34. #   if ICE_INT_VERSION % 100 < 1
  35. #       error Ice patch level mismatch!
  36. #   endif
  37. #endif
  39. namespace IceProxy
  40. {
  42. namespace Demo
  43. {
  45. class Transmit;
  46. bool operator==(const Transmit&, const Transmit& );
  47. bool operator!=(const Transmit&, const Transmit& );
  48. bool operator<(const Transmit&, const Transmit& );
  50. class Hello;
  51. bool operator==(const Hello&, const Hello& );
  52. bool operator!=(const Hello&, const Hello& );
  53. bool operator<(const Hello&, const Hello& );
  55. }
  57. }
  59. namespace Demo
  60. {
  62. class Transmit;
  63. bool operator==(const Transmit&, const Transmit& );
  64. bool operator!=(const Transmit&, const Transmit& );
  65. bool operator<(const Transmit&, const Transmit& );
  67. class Hello;
  68. bool operator==(const Hello&, const Hello& );
  69. bool operator!=(const Hello&, const Hello& );
  70. bool operator<(const Hello&, const Hello& );
  72. }
  74. namespace IceInternal
  75. {
  77. void incRef(::Demo::Transmit*);
  78. void decRef(::Demo::Transmit*);
  80. void incRef(::IceProxy::Demo::Transmit*);
  81. void decRef(::IceProxy::Demo::Transmit*);
  83. void incRef(::Demo::Hello*);
  84. void decRef(::Demo::Hello*);
  86. void incRef(::IceProxy::Demo::Hello*);
  87. void decRef(::IceProxy::Demo::Hello*);
  89. }
  91. namespace Demo
  92. {
  94. typedef ::IceInternal::Handle< ::Demo::Transmit> TransmitPtr;
  95. typedef ::IceInternal::ProxyHandle< ::IceProxy::Demo::Transmit> TransmitPrx;
  97. void __write(::IceInternal::BasicStream*, const TransmitPrx& );
  98. void __read(::IceInternal::BasicStream*, TransmitPrx& );
  99. void __write(::IceInternal::BasicStream*, const TransmitPtr& );
  100. void __patch__TransmitPtr(void*, ::Ice::ObjectPtr& );
  102. typedef ::IceInternal::Handle< ::Demo::Hello> HelloPtr;
  103. typedef ::IceInternal::ProxyHandle< ::IceProxy::Demo::Hello> HelloPrx;
  105. void __write(::IceInternal::BasicStream*, const HelloPrx& );
  106. void __read(::IceInternal::BasicStream*, HelloPrx& );
  107. void __write(::IceInternal::BasicStream*, const HelloPtr& );
  108. void __patch__HelloPtr(void*, ::Ice::ObjectPtr& );
  110. }
  112. namespace Demo
  113. {
  115. typedef ::std::vector< ::Ice::Double> array;
  117. }
  119. namespace IceProxy
  120. {
  122. namespace Demo
  123. {
  125. class Transmit : virtual public ::IceProxy::Ice::Object
  126. {
  127. public:
  128.    
  129.     static const ::std::string& ice_staticId();
  131. private:
  133.     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
  134.     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
  135. };
  137. class Hello : virtual public ::IceProxy::Ice::Object
  138. {
  139. public:
  141.     void sayHello(const ::std::string& );
  142.     void sayHello(const ::std::string&, const ::Ice::Context& );
  144.     ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double);
  145.     ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::Ice::Context& );
  147.     void sendClass(const ::Demo::TransmitPtr& );
  148.     void sendClass(const ::Demo::TransmitPtr&, const ::Ice::Context& );
  149.    
  150.     static const ::std::string& ice_staticId();
  152. private:
  154.     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
  155.     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
  156. };
  158. }
  160. }
  162. namespace IceDelegate
  163. {
  165. namespace Demo
  166. {
  168. class Transmit : virtual public ::IceDelegate::Ice::Object
  169. {
  170. public:
  171. };
  173. class Hello : virtual public ::IceDelegate::Ice::Object
  174. {
  175. public:
  177.     virtual void sayHello(const ::std::string&, const ::Ice::Context& ) = 0;
  179.     virtual ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::Ice::Context& ) = 0;
  181.     virtual void sendClass(const ::Demo::TransmitPtr&, const ::Ice::Context& ) = 0;
  182. };
  184. }
  186. }
  188. namespace IceDelegateM
  189. {
  191. namespace Demo
  192. {
  194. class Transmit : virtual public ::IceDelegate::Demo::Transmit,
  195.   virtual public ::IceDelegateM::Ice::Object
  196. {
  197. public:
  198. };
  200. class Hello : virtual public ::IceDelegate::Demo::Hello,
  201.       virtual public ::IceDelegateM::Ice::Object
  202. {
  203. public:
  205.     virtual void sayHello(const ::std::string&, const ::Ice::Context& );
  207.     virtual ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::Ice::Context& );
  209.     virtual void sendClass(const ::Demo::TransmitPtr&, const ::Ice::Context& );
  210. };
  212. }
  214. }
  216. namespace IceDelegateD
  217. {
  219. namespace Demo
  220. {
  222. class Transmit : virtual public ::IceDelegate::Demo::Transmit,
  223.   virtual public ::IceDelegateD::Ice::Object
  224. {
  225. public:
  226. };
  228. class Hello : virtual public ::IceDelegate::Demo::Hello,
  229.       virtual public ::IceDelegateD::Ice::Object
  230. {
  231. public:
  233.     virtual void sayHello(const ::std::string&, const ::Ice::Context& );
  235.     virtual ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::Ice::Context& );
  237.     virtual void sendClass(const ::Demo::TransmitPtr&, const ::Ice::Context& );
  238. };
  240. }
  242. }
  244. namespace Demo
  245. {
  247. class Transmit : virtual public ::Ice::Object
  248. {
  249. public:
  251.     Transmit() {};
  252.     Transmit(::Ice::Int, const ::Demo::array& );
  253.     virtual ::Ice::ObjectPtr ice_clone() const;
  255.     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
  256.     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
  257.     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
  258.     static const ::std::string& ice_staticId();
  260.     ::Ice::Int a;
  261.     ::Demo::array arr;
  263.     virtual void __write(::IceInternal::BasicStream*) const;
  264.     virtual void __read(::IceInternal::BasicStream*, bool);
  265.     virtual void __write(const ::Ice::OutputStreamPtr& ) const;
  266.     virtual void __read(const ::Ice::InputStreamPtr&, bool);
  268.     static const ::Ice::ObjectFactoryPtr& ice_factory();
  269. };
  271. static ::Demo::Transmit __Transmit_init;
  273. void __patch__TransmitPtr(void*, ::Ice::ObjectPtr& );
  275. class Hello : virtual public ::Ice::Object
  276. {
  277. public:
  279.     virtual ::Ice::ObjectPtr ice_clone() const;
  281.     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
  282.     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
  283.     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
  284.     static const ::std::string& ice_staticId();
  286.     virtual void sayHello(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const = 0;
  287.     ::IceInternal::DispatchStatus ___sayHello(::IceInternal::Incoming&, const ::Ice::Current& ) const;
  289.     virtual ::Demo::TransmitPtr setClass(::Ice::Int, ::Ice::Double, ::Ice::Double, ::Ice::Double, const ::Ice::Current& = ::Ice::Current()) = 0;
  290.     ::IceInternal::DispatchStatus ___setClass(::IceInternal::Incoming&, const ::Ice::Current& );
  292.     virtual void sendClass(const ::Demo::TransmitPtr&, const ::Ice::Current& = ::Ice::Current()) = 0;
  293.     ::IceInternal::DispatchStatus ___sendClass(::IceInternal::Incoming&, const ::Ice::Current& );
  295.     virtual ::IceInternal::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current& );
  297.     virtual void __write(::IceInternal::BasicStream*) const;
  298.     virtual void __read(::IceInternal::BasicStream*, bool);
  299.     virtual void __write(const ::Ice::OutputStreamPtr& ) const;
  300.     virtual void __read(const ::Ice::InputStreamPtr&, bool);
  301. };
  303. void __patch__HelloPtr(void*, ::Ice::ObjectPtr& );
  305. }
  307. #endif


 

Code :
  1. // **********************************************************************
  2. //
  3. // Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
  4. //
  5. // This copy of Ice is licensed to you under the terms described in the
  6. // ICE_LICENSE file included in this distribution.
  7. //
  8. // **********************************************************************
  10. // Ice version 3.0.1
  11. // Generated from file `Hello.ice'
  13. #include <Hello.h>
  14. #include <Ice/LocalException.h>
  15. #include <Ice/ObjectFactory.h>
  16. #include <Ice/BasicStream.h>
  17. #include <Ice/Object.h>
  19. #ifndef ICE_IGNORE_VERSION
  20. #   if ICE_INT_VERSION / 100 != 300
  21. #       error Ice version mismatch!
  22. #   endif
  23. #   if ICE_INT_VERSION % 100 < 1
  24. #       error Ice patch level mismatch!
  25. #   endif
  26. #endif
  28. void
  29. IceInternal::incRef(::Demo::Transmit* p)
  30. {
  31.     p->__incRef();
  32. }
  34. void
  35. IceInternal::decRef(::Demo::Transmit* p)
  36. {
  37.     p->__decRef();
  38. }
  40. void
  41. IceInternal::incRef(::IceProxy::Demo::Transmit* p)
  42. {
  43.     p->__incRef();
  44. }
  46. void
  47. IceInternal::decRef(::IceProxy::Demo::Transmit* p)
  48. {
  49.     p->__decRef();
  50. }
  52. void
  53. IceInternal::incRef(::Demo::Hello* p)
  54. {
  55.     p->__incRef();
  56. }
  58. void
  59. IceInternal::decRef(::Demo::Hello* p)
  60. {
  61.     p->__decRef();
  62. }
  64. void
  65. IceInternal::incRef(::IceProxy::Demo::Hello* p)
  66. {
  67.     p->__incRef();
  68. }
  70. void
  71. IceInternal::decRef(::IceProxy::Demo::Hello* p)
  72. {
  73.     p->__decRef();
  74. }
  76. void
  77. Demo::__write(::IceInternal::BasicStream* __os, const ::Demo::TransmitPrx& v)
  78. {
  79.     __os->write(::Ice::ObjectPrx(v));
  80. }
  82. void
  83. Demo::__read(::IceInternal::BasicStream* __is, ::Demo::TransmitPrx& v)
  84. {
  85.     ::Ice::ObjectPrx proxy;
  86.     __is->read(proxy);
  87.     if(!proxy)
  88.     {
  89. v = 0;
  90.     }
  91.     else
  92.     {
  93. v = new ::IceProxy::Demo::Transmit;
  94. v->__copyFrom(proxy);
  95.     }
  96. }
  98. void
  99. Demo::__write(::IceInternal::BasicStream* __os, const ::Demo::TransmitPtr& v)
  100. {
  101.     __os->write(::Ice::ObjectPtr(v));
  102. }
  104. void
  105. Demo::__write(::IceInternal::BasicStream* __os, const ::Demo::HelloPrx& v)
  106. {
  107.     __os->write(::Ice::ObjectPrx(v));
  108. }
  110. void
  111. Demo::__read(::IceInternal::BasicStream* __is, ::Demo::HelloPrx& v)
  112. {
  113.     ::Ice::ObjectPrx proxy;
  114.     __is->read(proxy);
  115.     if(!proxy)
  116.     {
  117. v = 0;
  118.     }
  119.     else
  120.     {
  121. v = new ::IceProxy::Demo::Hello;
  122. v->__copyFrom(proxy);
  123.     }
  124. }
  126. void
  127. Demo::__write(::IceInternal::BasicStream* __os, const ::Demo::HelloPtr& v)
  128. {
  129.     __os->write(::Ice::ObjectPtr(v));
  130. }
  132. const ::std::string&
  133. IceProxy::Demo::Transmit::ice_staticId()
  134. {
  135.     return ::Demo::Transmit::ice_staticId();
  136. }
  138. ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
  139. IceProxy::Demo::Transmit::__createDelegateM()
  140. {
  141.     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Demo::Transmit);
  142. }
  144. ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
  145. IceProxy::Demo::Transmit::__createDelegateD()
  146. {
  147.     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Demo::Transmit);
  148. }
  150. bool
  151. IceProxy::Demo::operator==(const ::IceProxy::Demo::Transmit& l, const ::IceProxy::Demo::Transmit& r)
  152. {
  153.     return static_cast<const ::IceProxy::Ice::Object&>(l) == static_cast<const ::IceProxy::Ice::Object&>(r);
  154. }
  156. bool
  157. IceProxy::Demo::operator!=(const ::IceProxy::Demo::Transmit& l, const ::IceProxy::Demo::Transmit& r)
  158. {
  159.     return static_cast<const ::IceProxy::Ice::Object&>(l) != static_cast<const ::IceProxy::Ice::Object&>(r);
  160. }
  162. bool
  163. IceProxy::Demo::operator<(const ::IceProxy::Demo::Transmit& l, const ::IceProxy::Demo::Transmit& r)
  164. {
  165.     return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
  166. }
  168. void
  169. IceProxy::Demo::Hello::sayHello(const ::std::string& s)
  170. {
  171.     sayHello(s, __defaultContext());
  172. }
  174. void
  175. IceProxy::Demo::Hello::sayHello(const ::std::string& s, const ::Ice::Context& __ctx)
  176. {
  177.     int __cnt = 0;
  178.     while(true)
  179.     {
  180. try
  181. {
  182.     ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
  183.     ::IceDelegate::Demo::Hello* __del = dynamic_cast< ::IceDelegate::Demo::Hello*>(__delBase.get());
  184.     __del->sayHello(s, __ctx);
  185.     return;
  186. }
  187. catch(const ::IceInternal::NonRepeatable& __ex)
  188. {
  189.     __handleException(*__ex.get(), __cnt);
  190. }
  191. catch(const ::Ice::LocalException& __ex)
  192. {
  193.     __handleException(__ex, __cnt);
  194. }
  195.     }
  196. }
  198. ::Demo::TransmitPtr
  199. IceProxy::Demo::Hello::setClass(::Ice::Int a, ::Ice::Double d1, ::Ice::Double d2, ::Ice::Double d3)
  200. {
  201.     return setClass(a, d1, d2, d3, __defaultContext());
  202. }
  204. ::Demo::TransmitPtr
  205. IceProxy::Demo::Hello::setClass(::Ice::Int a, ::Ice::Double d1, ::Ice::Double d2, ::Ice::Double d3, const ::Ice::Context& __ctx)
  206. {
  207.     int __cnt = 0;
  208.     while(true)
  209.     {
  210. try
  211. {
  212.     __checkTwowayOnly("setClass" );
  213.     ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
  214.     ::IceDelegate::Demo::Hello* __del = dynamic_cast< ::IceDelegate::Demo::Hello*>(__delBase.get());
  215.     return __del->setClass(a, d1, d2, d3, __ctx);
  216. }
  217. catch(const ::IceInternal::NonRepeatable& __ex)
  218. {
  219.     __handleException(*__ex.get(), __cnt);
  220. }
  221. catch(const ::Ice::LocalException& __ex)
  222. {
  223.     __handleException(__ex, __cnt);
  224. }
  225.     }
  226. }
  228. void
  229. IceProxy::Demo::Hello::sendClass(const ::Demo::TransmitPtr& trans)
  230. {
  231.     sendClass(trans, __defaultContext());
  232. }
  234. void
  235. IceProxy::Demo::Hello::sendClass(const ::Demo::TransmitPtr& trans, const ::Ice::Context& __ctx)
  236. {
  237.     int __cnt = 0;
  238.     while(true)
  239.     {
  240. try
  241. {
  242.     ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase = __getDelegate();
  243.     ::IceDelegate::Demo::Hello* __del = dynamic_cast< ::IceDelegate::Demo::Hello*>(__delBase.get());
  244.     __del->sendClass(trans, __ctx);
  245.     return;
  246. }
  247. catch(const ::IceInternal::NonRepeatable& __ex)
  248. {
  249.     __handleException(*__ex.get(), __cnt);
  250. }
  251. catch(const ::Ice::LocalException& __ex)
  252. {
  253.     __handleException(__ex, __cnt);
  254. }
  255.     }
  256. }
  258. const ::std::string&
  259. IceProxy::Demo::Hello::ice_staticId()
  260. {
  261.     return ::Demo::Hello::ice_staticId();
  262. }
  264. ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
  265. IceProxy::Demo::Hello::__createDelegateM()
  266. {
  267.     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Demo::Hello);
  268. }
  270. ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
  271. IceProxy::Demo::Hello::__createDelegateD()
  272. {
  273.     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Demo::Hello);
  274. }
  276. bool
  277. IceProxy::Demo::operator==(const ::IceProxy::Demo::Hello& l, const ::IceProxy::Demo::Hello& r)
  278. {
  279.     return static_cast<const ::IceProxy::Ice::Object&>(l) == static_cast<const ::IceProxy::Ice::Object&>(r);
  280. }
  282. bool
  283. IceProxy::Demo::operator!=(const ::IceProxy::Demo::Hello& l, const ::IceProxy::Demo::Hello& r)
  284. {
  285.     return static_cast<const ::IceProxy::Ice::Object&>(l) != static_cast<const ::IceProxy::Ice::Object&>(r);
  286. }
  288. bool
  289. IceProxy::Demo::operator<(const ::IceProxy::Demo::Hello& l, const ::IceProxy::Demo::Hello& r)
  290. {
  291.     return static_cast<const ::IceProxy::Ice::Object&>(l) < static_cast<const ::IceProxy::Ice::Object&>(r);
  292. }
  294. static const ::std::string __Demo__Hello__sayHello_name = "sayHello";
  296. void
  297. IceDelegateM::Demo::Hello::sayHello(const ::std::string& s, const ::Ice::Context& __context)
  298. {
  299.     ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Demo__Hello__sayHello_name, ::Ice::Nonmutating, __context, __compress);
  300.     try
  301.     {
  302. ::IceInternal::BasicStream* __os = __og.os();
  303. __os->write(s);
  304.     }
  305.     catch(const ::Ice::LocalException& __ex)
  306.     {
  307. __og.abort(__ex);
  308.     }
  309.     bool __ok = __og.invoke();
  310.     try
  311.     {
  312. ::IceInternal::BasicStream* __is = __og.is();
  313. if(!__ok)
  314. {
  315.     try
  316.     {
  317.  __is->throwException();
  318.     }
  319.     catch(const ::Ice::UserException& __ex)
  320.     {
  321.  throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
  322.     }
  323. }
  324.     }
  325.     catch(const ::Ice::LocalException& __ex)
  326.     {
  327. throw ::IceInternal::NonRepeatable(__ex);
  328.     }
  329. }
  331. static const ::std::string __Demo__Hello__setClass_name = "setClass";
  333. ::Demo::TransmitPtr
  334. IceDelegateM::Demo::Hello::setClass(::Ice::Int a, ::Ice::Double d1, ::Ice::Double d2, ::Ice::Double d3, const ::Ice::Context& __context)
  335. {
  336.     ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Demo__Hello__setClass_name, ::Ice::Idempotent, __context, __compress);
  337.     try
  338.     {
  339. ::IceInternal::BasicStream* __os = __og.os();
  340. __os->write(a);
  341. __os->write(d1);
  342. __os->write(d2);
  343. __os->write(d3);
  344.     }
  345.     catch(const ::Ice::LocalException& __ex)
  346.     {
  347. __og.abort(__ex);
  348.     }
  349.     bool __ok = __og.invoke();
  350.     try
  351.     {
  352. ::IceInternal::BasicStream* __is = __og.is();
  353. if(!__ok)
  354. {
  355.     try
  356.     {
  357.  __is->throwException();
  358.     }
  359.     catch(const ::Ice::UserException& __ex)
  360.     {
  361.  throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
  362.     }
  363. }
  364. ::Demo::TransmitPtr __ret;
  365. __is->read(::Demo::__patch__TransmitPtr, &__ret);
  366. __is->readPendingObjects();
  367. return __ret;
  368.     }
  369.     catch(const ::Ice::LocalException& __ex)
  370.     {
  371. throw ::IceInternal::NonRepeatable(__ex);
  372.     }
  373. }
  375. static const ::std::string __Demo__Hello__sendClass_name = "sendClass";
  377. void
  378. IceDelegateM::Demo::Hello::sendClass(const ::Demo::TransmitPtr& trans, const ::Ice::Context& __context)
  379. {
  380.     ::IceInternal::Outgoing __og(__connection.get(), __reference.get(), __Demo__Hello__sendClass_name, ::Ice::Idempotent, __context, __compress);
  381.     try
  382.     {
  383. ::IceInternal::BasicStream* __os = __og.os();
  384. ::Demo::__write(__os, trans);
  385. __os->writePendingObjects();
  386.     }
  387.     catch(const ::Ice::LocalException& __ex)
  388.     {
  389. __og.abort(__ex);
  390.     }
  391.     bool __ok = __og.invoke();
  392.     try
  393.     {
  394. ::IceInternal::BasicStream* __is = __og.is();
  395. if(!__ok)
  396. {
  397.     try
  398.     {
  399.  __is->throwException();
  400.     }
  401.     catch(const ::Ice::UserException& __ex)
  402.     {
  403.  throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
  404.     }
  405. }
  406.     }
  407.     catch(const ::Ice::LocalException& __ex)
  408.     {
  409. throw ::IceInternal::NonRepeatable(__ex);
  410.     }
  411. }
  413. void
  414. IceDelegateD::Demo::Hello::sayHello(const ::std::string& s, const ::Ice::Context& __context)
  415. {
  416.     ::Ice::Current __current;
  417.     __initCurrent(__current, "sayHello", ::Ice::Nonmutating, __context);
  418.     while(true)
  419.     {
  420. ::IceInternal::Direct __direct(__current);
  421. ::Demo::Hello* __servant = dynamic_cast< ::Demo::Hello*>(__direct.servant().get());
  422. if(!__servant)
  423. {
  424.     ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
  425.     __opEx.id = __current.id;
  426.     __opEx.facet = __current.facet;
  427.     __opEx.operation = __current.operation;
  428.     throw __opEx;
  429. }
  430. try
  431. {
  432.     __servant->sayHello(s, __current);
  433.     return;
  434. }
  435. catch(const ::Ice::LocalException& __ex)
  436. {
  437.     throw ::IceInternal::NonRepeatable(__ex);
  438. }
  439.     }
  440. }
  442. ::Demo::TransmitPtr
  443. IceDelegateD::Demo::Hello::setClass(::Ice::Int a, ::Ice::Double d1, ::Ice::Double d2, ::Ice::Double d3, const ::Ice::Context& __context)
  444. {
  445.     ::Ice::Current __current;
  446.     __initCurrent(__current, "setClass", ::Ice::Idempotent, __context);
  447.     while(true)
  448.     {
  449. ::IceInternal::Direct __direct(__current);
  450. ::Demo::Hello* __servant = dynamic_cast< ::Demo::Hello*>(__direct.servant().get());
  451. if(!__servant)
  452. {
  453.     ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
  454.     __opEx.id = __current.id;
  455.     __opEx.facet = __current.facet;
  456.     __opEx.operation = __current.operation;
  457.     throw __opEx;
  458. }
  459. try
  460. {
  461.     return __servant->setClass(a, d1, d2, d3, __current);
  462. }
  463. catch(const ::Ice::LocalException& __ex)
  464. {
  465.     throw ::IceInternal::NonRepeatable(__ex);
  466. }
  467.     }
  468. }
  470. void
  471. IceDelegateD::Demo::Hello::sendClass(const ::Demo::TransmitPtr& trans, const ::Ice::Context& __context)
  472. {
  473.     ::Ice::Current __current;
  474.     __initCurrent(__current, "sendClass", ::Ice::Idempotent, __context);
  475.     while(true)
  476.     {
  477. ::IceInternal::Direct __direct(__current);
  478. ::Demo::Hello* __servant = dynamic_cast< ::Demo::Hello*>(__direct.servant().get());
  479. if(!__servant)
  480. {
  481.     ::Ice::OperationNotExistException __opEx(__FILE__, __LINE__);
  482.     __opEx.id = __current.id;
  483.     __opEx.facet = __current.facet;
  484.     __opEx.operation = __current.operation;
  485.     throw __opEx;
  486. }
  487. try
  488. {
  489.     __servant->sendClass(trans, __current);
  490.     return;
  491. }
  492. catch(const ::Ice::LocalException& __ex)
  493. {
  494.     throw ::IceInternal::NonRepeatable(__ex);
  495. }
  496.     }
  497. }
  499. Demo::Transmit::Transmit(::Ice::Int __ice_a, const ::Demo::array& __ice_arr) :
  500.     a(__ice_a),
  501.     arr(__ice_arr)
  502. {
  503. }
  505. ::Ice::ObjectPtr
  506. Demo::Transmit::ice_clone() const
  507. {
  508.     ::Demo::TransmitPtr __p = new ::Demo::Transmit(*this);
  509.     return __p;
  510. }
  512. static const ::std::string __Demo__Transmit_ids[2] =
  513. {
  514.     "::Demo::Transmit",
  515.     "::Ice::Object"
  516. };
  518. bool
  519. Demo::Transmit::ice_isA(const ::std::string& _s, const ::Ice::Current& ) const
  520. {
  521.     return ::std::binary_search(__Demo__Transmit_ids, __Demo__Transmit_ids + 2, _s);
  522. }
  524. ::std::vector< ::std::string>
  525. Demo::Transmit::ice_ids(const ::Ice::Current& ) const
  526. {
  527.     return ::std::vector< ::std::string>(&__Demo__Transmit_ids[0], &__Demo__Transmit_ids[2]);
  528. }
  530. const ::std::string&
  531. Demo::Transmit::ice_id(const ::Ice::Current& ) const
  532. {
  533.     return __Demo__Transmit_ids[0];
  534. }
  536. const ::std::string&
  537. Demo::Transmit::ice_staticId()
  538. {
  539.     return __Demo__Transmit_ids[0];
  540. }
  542. void
  543. Demo::Transmit::__write(::IceInternal::BasicStream* __os) const
  544. {
  545.     __os->writeTypeId(ice_staticId());
  546.     __os->startWriteSlice();
  547.     __os->write(a);
  548.     __os->write(arr);
  549.     __os->endWriteSlice();
  550. #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
  551.     Object::__write(__os);
  552. #else
  553.     ::Ice::Object::__write(__os);
  554. #endif
  555. }
  557. void
  558. Demo::Transmit::__read(::IceInternal::BasicStream* __is, bool __rid)
  559. {
  560.     if(__rid)
  561.     {
  562. ::std::string myId;
  563. __is->readTypeId(myId);
  564.     }
  565.     __is->startReadSlice();
  566.     __is->read(a);
  567.     __is->read(arr);
  568.     __is->endReadSlice();
  569. #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
  570.     Object::__read(__is, true);
  571. #else
  572.     ::Ice::Object::__read(__is, true);
  573. #endif
  574. }
  576. void
  577. Demo::Transmit::__write(const ::Ice::OutputStreamPtr& ) const
  578. {
  579.     Ice::MarshalException ex(__FILE__, __LINE__);
  580.     ex.reason = "type Demo::Transmit was not generated with stream support";
  581.     throw ex;
  582. }
  584. void
  585. Demo::Transmit::__read(const ::Ice::InputStreamPtr&, bool)
  586. {
  587.     Ice::MarshalException ex(__FILE__, __LINE__);
  588.     ex.reason = "type Demo::Transmit was not generated with stream support";
  589.     throw ex;
  590. }
  592. class __F__Demo__Transmit : public ::Ice::ObjectFactory
  593. {
  594. public:
  596.     virtual ::Ice::ObjectPtr
  597.     create(const ::std::string& type)
  598.     {
  599. assert(type == ::Demo::Transmit::ice_staticId());
  600. return new ::Demo::Transmit;
  601.     }
  603.     virtual void
  604.     destroy()
  605.     {
  606.     }
  607. };
  609. static ::Ice::ObjectFactoryPtr __F__Demo__Transmit_Ptr = new __F__Demo__Transmit;
  611. const ::Ice::ObjectFactoryPtr&
  612. Demo::Transmit::ice_factory()
  613. {
  614.     return __F__Demo__Transmit_Ptr;
  615. }
  617. class __F__Demo__Transmit__Init
  618. {
  619. public:
  621.     __F__Demo__Transmit__Init()
  622.     {
  623. ::IceInternal::factoryTable->addObjectFactory(::Demo::Transmit::ice_staticId(), ::Demo::Transmit::ice_factory());
  624.     }
  626.     ~__F__Demo__Transmit__Init()
  627.     {
  628. ::IceInternal::factoryTable->removeObjectFactory(::Demo::Transmit::ice_staticId());
  629.     }
  630. };
  632. static __F__Demo__Transmit__Init __F__Demo__Transmit__i;
  634. #ifdef __APPLE__
  635. extern "C" { void __F__Demo__Transmit__initializer() {} }
  636. #endif
  638. void
  639. Demo::__patch__TransmitPtr(void* __addr, ::Ice::ObjectPtr& v)
  640. {
  641.     ::Demo::TransmitPtr* p = static_cast< ::Demo::TransmitPtr*>(__addr);
  642.     assert(p);
  643.     *p = ::Demo::TransmitPtr::dynamicCast(v);
  644.     if(v && !*p)
  645.     {
  646. ::Ice::NoObjectFactoryException e(__FILE__, __LINE__);
  647. e.type = ::Demo::Transmit::ice_staticId();
  648. throw e;
  649.     }
  650. }
  652. bool
  653. Demo::operator==(const ::Demo::Transmit& l, const ::Demo::Transmit& r)
  654. {
  655.     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
  656. }
  658. bool
  659. Demo::operator!=(const ::Demo::Transmit& l, const ::Demo::Transmit& r)
  660. {
  661.     return static_cast<const ::Ice::Object&>(l) != static_cast<const ::Ice::Object&>(r);
  662. }
  664. bool
  665. Demo::operator<(const ::Demo::Transmit& l, const ::Demo::Transmit& r)
  666. {
  667.     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
  668. }
  670. ::Ice::ObjectPtr
  671. Demo::Hello::ice_clone() const
  672. {
  673.     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
  674. }
  676. static const ::std::string __Demo__Hello_ids[2] =
  677. {
  678.     "::Demo::Hello",
  679.     "::Ice::Object"
  680. };
  682. bool
  683. Demo::Hello::ice_isA(const ::std::string& _s, const ::Ice::Current& ) const
  684. {
  685.     return ::std::binary_search(__Demo__Hello_ids, __Demo__Hello_ids + 2, _s);
  686. }
  688. ::std::vector< ::std::string>
  689. Demo::Hello::ice_ids(const ::Ice::Current& ) const
  690. {
  691.     return ::std::vector< ::std::string>(&__Demo__Hello_ids[0], &__Demo__Hello_ids[2]);
  692. }
  694. const ::std::string&
  695. Demo::Hello::ice_id(const ::Ice::Current& ) const
  696. {
  697.     return __Demo__Hello_ids[0];
  698. }
  700. const ::std::string&
  701. Demo::Hello::ice_staticId()
  702. {
  703.     return __Demo__Hello_ids[0];
  704. }
  706. ::IceInternal::DispatchStatus
  707. Demo::Hello::___sayHello(::IceInternal::Incoming& __inS, const ::Ice::Current& __current) const
  708. {
  709.     __checkMode(::Ice::Nonmutating, __current.mode);
  710.     ::IceInternal::BasicStream* __is = __inS.is();
  711.     ::std::string s;
  712.     __is->read(s);
  713.     sayHello(s, __current);
  714.     return ::IceInternal::DispatchOK;
  715. }
  717. ::IceInternal::DispatchStatus
  718. Demo::Hello::___setClass(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
  719. {
  720.     __checkMode(::Ice::Idempotent, __current.mode);
  721.     ::IceInternal::BasicStream* __is = __inS.is();
  722.     ::IceInternal::BasicStream* __os = __inS.os();
  723.     ::Ice::Int a;
  724.     ::Ice::Double d1;
  725.     ::Ice::Double d2;
  726.     ::Ice::Double d3;
  727.     __is->read(a);
  728.     __is->read(d1);
  729.     __is->read(d2);
  730.     __is->read(d3);
  731.     ::Demo::TransmitPtr __ret = setClass(a, d1, d2, d3, __current);
  732.     ::Demo::__write(__os, __ret);
  733.     __os->writePendingObjects();
  734.     return ::IceInternal::DispatchOK;
  735. }
  737. ::IceInternal::DispatchStatus
  738. Demo::Hello::___sendClass(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
  739. {
  740.     __checkMode(::Ice::Idempotent, __current.mode);
  741.     ::IceInternal::BasicStream* __is = __inS.is();
  742.     ::Demo::TransmitPtr trans;
  743.     __is->read(::Demo::__patch__TransmitPtr, &trans);
  744.     __is->readPendingObjects();
  745.     sendClass(trans, __current);
  746.     return ::IceInternal::DispatchOK;
  747. }
  749. static ::std::string __Demo__Hello_all[] =
  750. {
  751.     "ice_id",
  752.     "ice_ids",
  753.     "ice_isA",
  754.     "ice_ping",
  755.     "sayHello",
  756.     "sendClass",
  757.     "setClass"
  758. };
  760. ::IceInternal::DispatchStatus
  761. Demo::Hello::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
  762. {
  763.     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Demo__Hello_all, __Demo__Hello_all + 7, current.operation);
  764.     if(r.first == r.second)
  765.     {
  766. return ::IceInternal::DispatchOperationNotExist;
  767.     }
  769.     switch(r.first - __Demo__Hello_all)
  770.     {
  771. case 0:
  772. {
  773.     return ___ice_id(in, current);
  774. }
  775. case 1:
  776. {
  777.     return ___ice_ids(in, current);
  778. }
  779. case 2:
  780. {
  781.     return ___ice_isA(in, current);
  782. }
  783. case 3:
  784. {
  785.     return ___ice_ping(in, current);
  786. }
  787. case 4:
  788. {
  789.     return ___sayHello(in, current);
  790. }
  791. case 5:
  792. {
  793.     return ___sendClass(in, current);
  794. }
  795. case 6:
  796. {
  797.     return ___setClass(in, current);
  798. }
  799.     }
  801.     assert(false);
  802.     return ::IceInternal::DispatchOperationNotExist;
  803. }
  805. void
  806. Demo::Hello::__write(::IceInternal::BasicStream* __os) const
  807. {
  808.     __os->writeTypeId(ice_staticId());
  809.     __os->startWriteSlice();
  810.     __os->endWriteSlice();
  811. #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
  812.     Object::__write(__os);
  813. #else
  814.     ::Ice::Object::__write(__os);
  815. #endif
  816. }
  818. void
  819. Demo::Hello::__read(::IceInternal::BasicStream* __is, bool __rid)
  820. {
  821.     if(__rid)
  822.     {
  823. ::std::string myId;
  824. __is->readTypeId(myId);
  825.     }
  826.     __is->startReadSlice();
  827.     __is->endReadSlice();
  828. #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
  829.     Object::__read(__is, true);
  830. #else
  831.     ::Ice::Object::__read(__is, true);
  832. #endif
  833. }
  835. void
  836. Demo::Hello::__write(const ::Ice::OutputStreamPtr& ) const
  837. {
  838.     Ice::MarshalException ex(__FILE__, __LINE__);
  839.     ex.reason = "type Demo::Hello was not generated with stream support";
  840.     throw ex;
  841. }
  843. void
  844. Demo::Hello::__read(const ::Ice::InputStreamPtr&, bool)
  845. {
  846.     Ice::MarshalException ex(__FILE__, __LINE__);
  847.     ex.reason = "type Demo::Hello was not generated with stream support";
  848.     throw ex;
  849. }
  851. void
  852. Demo::__patch__HelloPtr(void* __addr, ::Ice::ObjectPtr& v)
  853. {
  854.     ::Demo::HelloPtr* p = static_cast< ::Demo::HelloPtr*>(__addr);
  855.     assert(p);
  856.     *p = ::Demo::HelloPtr::dynamicCast(v);
  857.     if(v && !*p)
  858.     {
  859. ::Ice::NoObjectFactoryException e(__FILE__, __LINE__);
  860. e.type = ::Demo::Hello::ice_staticId();
  861. throw e;
  862.     }
  863. }
  865. bool
  866. Demo::operator==(const ::Demo::Hello& l, const ::Demo::Hello& r)
  867. {
  868.     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
  869. }
  871. bool
  872. Demo::operator!=(const ::Demo::Hello& l, const ::Demo::Hello& r)
  873. {
  874.     return static_cast<const ::Ice::Object&>(l) != static_cast<const ::Ice::Object&>(r);
  875. }
  877. bool
  878. Demo::operator<(const ::Demo::Hello& l, const ::Demo::Hello& r)
  879. {
  880.     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
  881. }


 
 
voici mes erreurs :
 

Code :
  1. Performing Custom Build Step on .\Hello.ice
  2. Compiling...
  3. Hello.cpp
  4. HelloI.cpp
  5. Server.cpp
  6. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : error C2259: 'HelloI' : cannot instantiate abstract class due to following members:
  7.         .\HelloI.h(18) : see declaration of 'HelloI'
  8. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'void __thiscall Demo::Hello::sayHello(const class _STL::basic_string<char,class _STL::char_traits<char>,class _STL::allocator<char> > &,const struct Ice::Current & ) const' :
  9. pure virtual function was not defined
  10.         .\Hello.h(286) : see declaration of 'sayHello'
  11. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'class IceInternal::Handle<class Demo::Transmit> __thiscall Demo::Hello::setClass(int,double,double,double,const struct Ice::Current & )' : pure virtual function was not defin
  12. ed
  13.         .\Hello.h(289) : see declaration of 'setClass'
  14. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'void __thiscall Demo::Hello::sendClass(const class IceInternal::Handle<class Demo::Transmit> &,const struct Ice::Current & )' : pure virtual function was not defined
  15.         .\Hello.h(292) : see declaration of 'sendClass'
  16. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : error C2259: 'HelloI' : cannot instantiate abstract class due to following members:
  17.         .\HelloI.h(18) : see declaration of 'HelloI'
  18. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'void __thiscall Demo::Hello::sayHello(const class _STL::basic_string<char,class _STL::char_traits<char>,class _STL::allocator<char> > &,const struct Ice::Current & ) const' :
  19. pure virtual function was not defined
  20.         .\Hello.h(286) : see declaration of 'sayHello'
  21. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'class IceInternal::Handle<class Demo::Transmit> __thiscall Demo::Hello::setClass(int,double,double,double,const struct Ice::Current & )' : pure virtual function was not defin
  22. ed
  23.         .\Hello.h(289) : see declaration of 'setClass'
  24. C:\Ice-3.0.1-VC60\demo\Ice\Copy of minimal\Server.cpp(26) : warning C4259: 'void __thiscall Demo::Hello::sendClass(const class IceInternal::Handle<class Demo::Transmit> &,const struct Ice::Current & )' : pure virtual function was not defined
  25.         .\Hello.h(292) : see declaration of 'sendClass'
  26. Generating Code...
  27. Error executing cl.exe.
  29. server.exe - 2 error(s), 6 warning(s)


 
J'espere avoir ete assez clair !!
 
Je vous remerciepour votre aide  :jap:

Reply

Marsh Posté le 07-03-2006 à 09:53:11   

Reply

Marsh Posté le 07-03-2006 à 10:51:58    

[:moule_bite] t'as pas plus long ?
 
Sinon les erreurs sont bien expliquées par le compilo : t'as des fonctions virtuelles pure(=fonction abstract en java), ce qui rends ta classe abstraite, et t'essaye d'instancier une de ces classes

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed