Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
641 connectés 

  FORUM HardWare.fr
  Programmation
  C++

  de java vers c++

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

de java vers c++

n°1319931
crazy_ride​r
Posté le 07-03-2006 à 09:53:11  profilanswer
 

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:

mood
Publicité
Posté le 07-03-2006 à 09:53:11  profilanswer
 

n°1320002
chrisbk
-
Posté le 07-03-2006 à 10:51:58  profilanswer
 

[: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


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C++

  de java vers c++

 

Sujets relatifs
[JAVA] Migration d'une applet vers un logiciel[java][debutant] string vers date
[Resolu * 2]solution de mapping java vers javatomcat jsp: comment fonctionne l'encodage URL vers java?
exportation du contenu d'une base de donnée vers xml avec javaexportation du contenu d'une base de donnée vers xml avec java
exportation du contenu d'une base de donnée vers xml avec javaApplet Java : Redimensioner une image + upload vers FTP
[java] une lib de conversion texte vers html ?Migrer un projet java vers linux
Plus de sujets relatifs à : de java vers c++

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.461 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR