ACE_DLList双向链表

最新推荐文章于 2021-03-21 05:43:35 发布
最新推荐文章于 2021-03-21 05:43:35 发布
阅读量1.2k 收藏
点赞数
分类专栏： ACE 文章标签： ACE ACE_DLList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yestda/article/details/11396737
版权

ACE内存分配宏：

      ACE_NEW ( P, C)  ///使用构造器c分配内存，并把指针赋给p。在失败时，p被设置为0并执行return；

      ACE_NEW_RETURN ( P, C, R)  ///使用构造器c分配内存，并把指针赋给p。在失败时，p被设置为0并执行return r;

      ACE_NEW_NORETURN ( P, C)  ///使用构造器c分配内存，并把指针赋给p。在失败时，p被设置为0并执行下一条语句；

ACE日志宏：

      ACE_ASSERT( TEST );   //测试失败，打印一条断言消息，然后应用终止。

      ACE_RETURN( VALUE );  //不打印消息，发出调用的函数会返回，返回值为value；op_status被设为value；

      ACE_DEBUG ( ( Severity, formatting-args ) );

      ACE_ERROR ( ( Severity, formatting-args ) );

      ACE_TRACE ( STRING );

ACE_DLList: 双向链表在序列中同时维护有向前和后向的链接，从而可以高效的进行向前或向后的遍历，但不能对元素进行随机访问。它是一个引用容器，而非值容器，它只存储指向你插入其中的值得指针。以下DataElement会记住自己现在有多少个实例。

main.cpp

#include "ListTest.h"

int DataElement::count_=0; 

#pragma comment(lib, "E:\\ACE_wrappers\\lib\\ACEd.lib") 

int ACE_TMAIN(int, ACE_TCHAR *[])//int main()
{
	ListTest mylist;

	return mylist.run();
}

DataElement 

class DataElement
{
	friend class DataElementEx;

public:
	DataElement() { count_++; }

	DataElement(int data):data_(data) { count_++; }

	DataElement(const DataElement & e)
	{
		data_=e.getData();
		count_++;
	}

	DataElement & operator= (const DataElement & e)
	{
		data_=e.getData();
		return *this;
	}

	bool operator== (const DataElement & e)
	{ return this->data_==e.data_; }

	~DataElement() { count_--; }

	int getData(void) const { return data_; }

	void setData(int val) { data_=val; }

	static int numOfActiveObjects(void) { return count_; }

private:
	int data_;
	static int count_;
};

listTest类： 

// ListTest.h: interface for the ListTest class.
//
//

#if !defined(AFX_LISTTEST_H__BA088283_594B_4459_9950_6E3DC1FA5D48__INCLUDED_)
#define AFX_LISTTEST_H__BA088283_594B_4459_9950_6E3DC1FA5D48__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "DataElement.h"
#include "ace/Containers.h"

typedef ACE_DLList<DataElement> MyList;

class ListTest  
{
public:
	ListTest();
	virtual ~ListTest();
	int run(void);
	void displayList(MyList & list);
	void destroyList(MyList & list);

};

#endif // !defined(AFX_LISTTEST_H__BA088283_594B_4459_9950_6E3DC1FA5D48__INCLUDED_)

实现文件： 

// ListTest.cpp: implementation of the ListTest class.
//
//

#include "ListTest.h"

//
// Construction/Destruction
//

ListTest::ListTest()
{

}

ListTest::~ListTest()
{

}

int ListTest::run()
{
	ACE_TRACE(ACE_TEXT("ListTest::run"));

	MyList list1;

	for(int i=0; i<100; i++)
	{
		DataElement *element;
		ACE_NEW_RETURN (element, DataElement(i), -1);
		list1.insert_tail(element);
	}
	this->displayList(list1);

	MyList list2;
	list2=list1;

	this->displayList(list2);

	this->destroyList(list2);

	ACE_DEBUG((LM_DEBUG,ACE_TEXT("# of live objects: %d\n"),DataElement::numOfActiveObjects()));
	
	return 0;
}

void ListTest::displayList(MyList & list)
{
	ACE_TRACE(ACE_TEXT("ListTest::displayTest"));

	ACE_DEBUG((LM_DEBUG,ACE_TEXT("Forward iteration\n")));
	ACE_DLList_Iterator<DataElement> iter(list);
	while(!iter.done())
	{
		ACE_DEBUG((LM_DEBUG,ACE_TEXT("%d:"),iter.next()->getData()));
		iter++;
	}

	ACE_DEBUG((LM_DEBUG,ACE_TEXT("\n")));

	ACE_DEBUG((LM_DEBUG,ACE_TEXT("Reverse Iteration\n")));

	ACE_DLList_Reverse_Iterator<DataElement> riter(list);

	while(!riter.done())
	{
		ACE_DEBUG((LM_DEBUG,ACE_TEXT("%d:"),riter.next()->getData()));
		riter++;
	}
	ACE_DEBUG((LM_DEBUG,ACE_TEXT("\n")));
}

void ListTest::destroyList(MyList & list)
{
	ACE_TRACE(ACE_TEXT("ListTest::destroyTest"));

	ACE_DEBUG((LM_DEBUG,ACE_TEXT("Destroy data element\n")));

	for(ACE_DLList_Iterator<DataElement> iter(list);
	!iter.done();
	iter++)
	{
		DataElement *de=iter.next();
		delete de;
	}
}

打印结果：

Forward iteration
0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15:16:17:18:19:20:21:22:23:24:25:26:27:28:29:
30:31:32:33:34:35:36:37:38:39:40:41:42:43:44:45:46:47:48:49:50:51:52:53:54:55:56
:57:58:59:60:61:62:63:64:65:66:67:68:69:70:71:72:73:74:75:76:77:78:79:80:81:82:8
3:84:85:86:87:88:89:90:91:92:93:94:95:96:97:98:99:
Reverse Iteration
99:98:97:96:95:94:93:92:91:90:89:88:87:86:85:84:83:82:81:80:79:78:77:76:75:74:73
:72:71:70:69:68:67:66:65:64:63:62:61:60:59:58:57:56:55:54:53:52:51:50:49:48:47:4
6:45:44:43:42:41:40:39:38:37:36:35:34:33:32:31:30:29:28:27:26:25:24:23:22:21:20:
19:18:17:16:15:14:13:12:11:10:9:8:7:6:5:4:3:2:1:0:
Forward iteration
0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15:16:17:18:19:20:21:22:23:24:25:26:27:28:29:
30:31:32:33:34:35:36:37:38:39:40:41:42:43:44:45:46:47:48:49:50:51:52:53:54:55:56
:57:58:59:60:61:62:63:64:65:66:67:68:69:70:71:72:73:74:75:76:77:78:79:80:81:82:8
3:84:85:86:87:88:89:90:91:92:93:94:95:96:97:98:99:
Reverse Iteration
99:98:97:96:95:94:93:92:91:90:89:88:87:86:85:84:83:82:81:80:79:78:77:76:75:74:73
:72:71:70:69:68:67:66:65:64:63:62:61:60:59:58:57:56:55:54:53:52:51:50:49:48:47:4
6:45:44:43:42:41:40:39:38:37:36:35:34:33:32:31:30:29:28:27:26:25:24:23:22:21:20:
19:18:17:16:15:14:13:12:11:10:9:8:7:6:5:4:3:2:1:0:
Destroy data element
# of live objects: 0

c_tianzi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACE 容器之二 ACE_DLList 的使用
点点滴滴
07-16 1521
下边的代码演示了如何使用ACE容器 ACE_DLLList 的使用方法，从名字上看，就可以知道这是一个动态的List，所以在使用的过程中和 STL 提供的 list 还是有很大的不同的。   // ACElist.cpp : Defines the entry point for the console application. // #include "stdafx.h" #inc
ACE篇之五：ACE容器之一（双向链表）
daleboy的专栏
09-04 569
前沿：为了跨平台的需要，以及性能考虑，ACE创建了自己的容器。ACE支持两种容器：基于模板的、类型安全的容器，以及基于对象的容器。基于模板的容器：允许在编译时创建“针对特定类型的容器”；基于对象的容器：支持某一类对象类型的插入和删除。ACE的容器包含两类：序列容器和关联容器。序列容器是一种其元素按照线性顺序排列的容器。由于要在容器中进行迭代，各个元素的顺序不会改变。列表、栈、队列、数组
ACE双向链表用法
程序点滴
02-25 725
演示了ACE双向链表与STD链表的用法// EchoServer.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include "ace/Containers.h"#include "ace/Log_Msg.h"#include using namespace std;int ACE_TMAIN(int argc, ACE_TC
双向链表C++实现
weixin_44844149的博客
06-09 332
在设计链表增删操作的方法时，要注意增删位置在链表中的位置，就只有三种情况，head位置，tail位置和中间位置，不同位置对指针的连接方式会有不同，一般都要用if进行判断，这些在代码中已经解释的很详细了。除此之外，在首尾进行操作时，也要对节点数量进行判断，也有三种情况，最简单的情形是空链表，其次是单节点，再就是一般的多节点情形，针对不同的情形用if进行判断，并做好指针维护即可，这些在代码中也有详细的...
java中dl列表,java中List集合及其遍历详解
weixin_42299728的博客
03-21 152
1. 首先List集合继承与Collection，是一个接口。① Collection (集合框架是JDK1.2版本出现的)② list:是有序的，元素可以重复，以为该集合体系有索引。经常用到的是实现该接口的ArrayList和LinkedList类③ Arraylist: 底层的数据结构使用的是数组结构，特点： 查询速度很快，但是增删稍慢。线程不同步LinkedList： 底层使用的...
list_code.rar_hash unix_单向链表
09-22
例如，`ws_dllist.h`可能定义了链表节点的结构体，`ws_dllist.c`则实现了相关操作的函数。 接下来，我们谈谈哈希表。哈希表是一种数据结构，它提供了快速的数据查找、插入和删除操作，平均时间复杂度为O(1)。哈希表...
3-3双向链表的基本操作1
08-03
首先，我们需要定义双向链表类`DLList`，这里使用C++模板类的方式实现，可以支持不同类型的元素。在`DLList`类中，有两个重要的成员变量，`head`和`tail`，分别表示链表的头结点和尾结点，`size`用于记录链表中的...
DoublyLinkedList:用 Java 实现双向链表
06-04
双向链表 使用 Eclipse、Maven、JUnit、SonarQube 和 JaCoCo 使用 Java 实现双向链表。 嵌套类摘要 private class DLNode 现场总结 - DLNode<T> first - DLNode<T> last 构造函数总结 + DLList() 方法总结 + ...
双向链表中插入结点并输出
最新发布
03-26
以下是 Python 代码实现双向链表中的插入操作，并输出整个链表： ```python class Node: def __init__(self, data=None): self.data = data self.prev = None self.next = None class DoublyLinkedList: def ...
dl列表标签的一些介绍，感觉还是不错的！
limeiyans喜欢编程的那些事
03-09 1237
DL -定义列表: 例子: Wheeple To whistle feebly Tyrotoxism To be poisoned by cheese dl:代码: Term 1 Definition of term 1 Term 2 Definition of term 2 定义列表是一个更复杂的比ul或ol标签。而不是让子弹或数字,它缩进: D
LiteOS：盘点那些重要的数据结构
华为云官方博客
02-23 1765
摘要：本文会给读者介绍下LiteOS源码中常用的几个数据结构，包括: 双向循环链表LOS_DL_LIST，优先级队列Priority Queue，排序链表SortLinkList等。 在学习Huawei LiteOS源代码的时候，常常会遇到一些数据结构的使用。如果没有掌握这它们的用法，阅读LiteOS源代码的时候会很费解、很吃力。本文会给读者介绍下LiteOS源码中常用的几个数据结构，包括: 双向循环链表LOS_DL_LIST，优先级队列Priority Queue，排序链表SortLinkList等..
内核链表
afootball的博客
09-18 255
代码demon #include <stdio.h> #include <stdlib.h> #include <string.h> #define SIZE 20 struct dl_list { struct dl_list *next; struct dl_list *prev; }; //初始化链表，前驱等于后继 static inline void dl_list_init(struct dl_list *list) { list->next
双向链表
01-07 862
文中的代码都来至wpa_supplicant_0.7.2\src\utils\list.h，学习并做了点注释 双向链表的操作代码： /** * struct dl_list - Doubly-linked list */ struct dl_list { struct dl_list *next; struct dl_list *prev; }; static inline voi
C++实现双向链表
chriselp
10-06 390
/* * DLList.h * * Created on: Oct 6, 2015 * Author: chris */ #ifndef DLLIST_H_ #define DLLIST_H_ typedef int ElemType; typedef struct DLNode{ ElemType data; DLNode* prior; DLNode* nex
nachos下的线程编程3
weixin_30883271的博客
12-05 328
　　　　　　　　　　　　　　　　　　nachos下的线程编程 一、 实验内容 本次实验的目的在于掌握使用nachos中的线程来解决较为复杂的并发问题。实验内容分三部分：实现事件栅栏原语并进行正确性测试；实现闹钟原语并进行正确性测试；利用事件栅栏和闹钟原语来解决电梯问题 实现事件栅栏原语 事件栅栏（EventBarrier）是一种同步机制，使用事件栅栏可以让一组线程以同步的方式等...
vxworks常用数据结构
kukumouse的专栏
04-09 2443
一: 基本数据结构 typedef struct node/* Node of a linked list. */ { struct node *next;/* Points at the next node in the list */ struct node *previous;/* Points at the previous node in the list */ } NODE; type
双链表的基本操作
今晚打老虎
10-11 438
http://blog.csdn.net/gaoxiang_/article/details/8279536  双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。       为了练习，我这次设置了哨兵结点，哨兵结点，我个人理解就是我们一般意义上的头结点（是链
list_add_tail 双向链表实现分析
06-12 4146
在看内核v4l2示例代码driver/media/video/vivi.c时 ，看到list_add_tail()函数，现在对其进行分析： struct list_head { struct list_head *next, *prev; }; list_add_tail(&buf->vb.queue, &vid->active); /** * list_add_tail
尽量使用STL而不是ACE的容器
C++是促进脑死亡的最佳方式
09-12 2191
 13         尽量使用STL而不是ACE的容器这个纯属个人感觉（偏见）。我有如下理由不使用ACE的容器：l      一些实现不符合大家对于容器的认识，比如ACE_DLList，在其中存放的居然是对象的指针而不是拷贝。你还必须记住去释放ACE_DLList内部管理的指针。l      ACE容器的迭代器不符合STL的要求，从而造成ACE的容器无法使用STL的各种模板算法和
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值