网上的例子编译通不过，求帮助

子牛

1. // test1.cpp : Defines the entry point for the console application.
2. //
4. #include "stdafx.h"
5. #include "ace/Malloc.h"
6. #include "ace/OS.h"
7. #include "ace/ACE.h"
8. #include "ace/Malloc_T.h"
9. #include "ace/Synch_Traits.h "
10. //#include "ace/Cached_Allocator.h"
11. //#include "ace/SYNCH_MUTEX.h"
13. //A chunk of size 1K is created. In our case we decided to use a simple array
15. //as the type for the chunk. Instead of this we could use any struct or class
17. //that we think is appropriate.
19. typedef char  MEMORY_BLOCK[1024];
20. //Create an ACE_Cached_Allocator which is passed in the type of the
22. //“chunk” that it must pre-allocate and assign on the free list.
24. // Since the Cached_Allocator is a template class we can pretty much
26. //pass it ANY type we think is appropriate to be a memory block.
28. typedef ACE_Cached_Allocator<MEMORY_BLOCK,ACE_SYNCH_MUTEX> Allocator;
31. class MessageManager
33. {
35. public:
37.         //The constructor is passed the number of chunks that the allocator
39.         //should pre-allocate and maintain on its free list.
41.         MessageManager(int n_blocks):
43.           allocator_(n_blocks),message_count_(0)
45.           {
47.                   mesg_array_=new char*[n_blocks];
49.           }
51.           
53.           //Allocate memory for a message using the Allocator. Remember the message
55.           //in an array and then increase the message count of valid messages
57.           //on the message array.
59.           void allocate_msg(const char *msg)
61.           {
63.                   mesg_array_[message_count_]=(char*)allocator_.malloc(ACE_OS::strlen(msg)+1);
65.                   ACE_OS::strcpy(mesg_array_[message_count_],msg);
67.                   message_count_++;
69.           }
71.           
73.           //Free all the memory that was allocated. This will cause the chunks
75.           //to be returned to the allocator’s internal free list
77.           //and NOT to the OS.
79.           void free_all_msg()
81.           {
83.                   for(int i=0;i<message_count_;i++)
85.                           allocator_.free(mesg_array_[i]);
87.                   
89.                   message_count_=0;
91.           }
93.           
95.           //Just show all the currently allocated messages in the message array.
97.           void display_all_msg()
99.           {
101.                   for(int i=0;i<message_count_;i++)
103.                           ACE_OS::printf("%s\n",mesg_array_[i]);
105.           }
107.           
109. private:
111.         char **mesg_array_;
113.         Allocator allocator_;
115.         int message_count_;
117. };
119. char message[100];
121. int main(int argc, char* argv[])
123. {
125.         if(argc<2)
127.         {
129.                 ACE_DEBUG((LM_DEBUG, "Usage: %s <Number of blocks>\n", argv[0]));
131.                 exit(1);
133.         }
135.        
137.         int n_blocks=ACE_OS::atoi(argv[1]);
139.        
141.         //Instantiate the Memory Manager class and pass in the number of blocks
143.         //you want on the internal free list.
145.         MessageManager mm(n_blocks);
147.        
149.         //Use the Memory Manager class to assign messages and free them.
151.         //Run this in your favorite debug environment and you will notice that the
153.         //amount of memory your program uses after Memory Manager has been
155.         //instantiated remains the same. That means the Cached Allocator
157.         //controls or manages all the memory for the application.
159.         //Do forever.
161.         while(1)
163.         {
165.                 //allocate the messages somewhere
167.                 ACE_DEBUG((LM_DEBUG,"\n\n\nAllocating Messages\n"));
169.                 for(int i=0; i<n_blocks;i++){
171.                         ACE_OS::sprintf(message,"Message %d: Hi There",i);
173.                         mm.allocate_msg(message);
175.                 }
177.                
179.                 //show the messages
181.                 ACE_DEBUG((LM_DEBUG,"Displaying the messages\n"));
183.                 ACE_OS::sleep(2);
185.                 mm.display_all_msg();
187.                
189.                 //free up the memory for the messages.
191.                 ACE_DEBUG((LM_DEBUG,"Releasing Messages\n"));
193.                 ACE_OS::sleep(2);
195.                 mm.free_all_msg();
197.         }
199.        
201.         return 0;
203. }

复制代码

winston

问题是啥？细节！大家有几个人有时间帮你调试程序啊

子牛

1. 1>------ Build started: Project: test1, Configuration: Debug Win32 ------
2. 1>Compiling...
3. 1>test1.cpp
4. 1>e:\ace-6.1.0\ace_wrappers\ace\free_list.h(131) : error C2079: 'ACE_Locked_Free_List<T,ACE_LOCK>::mutex_' uses undefined class 'ACE_Thread_Mutex'
5. 1>        with
6. 1>        [
7. 1>            T=ACE_Cached_Mem_Pool_Node<MEMORY_BLOCK >,
8. 1>            ACE_LOCK=ACE_MT_SYNCH::MUTEX
9. 1>        ]
10. 1>        e:\ace-6.1.0\ace_wrappers\ace\malloc_t.h(130) : see reference to class template instantiation 'ACE_Locked_Free_List<T,ACE_LOCK>' being compiled
11. 1>        with
12. 1>        [
13. 1>            T=ACE_Cached_Mem_Pool_Node<MEMORY_BLOCK >,
14. 1>            ACE_LOCK=ACE_MT_SYNCH::MUTEX
15. 1>        ]
16. 1>        e:\ace-6.1.0\ace_test\test1\test1.cpp(113) : see reference to class template instantiation 'ACE_Cached_Allocator<T,ACE_LOCK>' being compiled
17. 1>        with
18. 1>        [
19. 1>            T=MEMORY_BLOCK,
20. 1>            ACE_LOCK=ACE_MT_SYNCH::MUTEX
21. 1>        ]
22. 1>Build log was saved at "file://e:\ACE-6.1.0\ACE_TEST\test1\Debug\BuildLog.htm"
23. 1>test1 - 1 error(s), 0 warning(s)
24. ========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

复制代码

子牛

这是什么错误啊，是不是MEMORY_BLOCK要搞成类

winston

include ACE_Thread_Mutex 这个类的头文件。