C++ Template Class List

转载请注明： http://blog.csdn.net/c602273091/article/details/50717999

Introduction STL

STL（Standard Template Library，标准模板库)是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。现在虽说它主要出现在C++中，但在被引入C++之前该技术就已经存在了很长的一段时间。

STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

在C++标准中，STL被组织为下面的13头文件：

algorithm、deque、 functional、iterator、vector、list、map、memory、numeric、queue、set、stack、utility。

http://www.cnblogs.com/shiyangxt/archive/2008/09/11/1289493.html

Algorithm

大家都能取得的一个共识是函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比使用整型作为它的参数类性要高。而C++通过模板的机制允许推迟对某些类型的选择，直到真正想使用模板或者说对模板进行特化的时候，STL就利用了这一点提供了相当多的有用算法。它是在一个有效的框架中完成这些算法的——你可以将所有的类型划分为少数的几类，然后就可以在模版的参数中使用一种类型替换掉同一种类中的其他类型。

STL提供了大约100个实现算法的模版函数，比如算法for_each将为指定序列中的每一个元素调用指定的函数，stable_sort以你所指定的规则对序列进行稳定性排序等等。这样一来，只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。

算法部分主要由头文件algorithm，numeric 和 functional组成。

algorithm 是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。

numeric 体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。

functional 中则定义了一些模板类，用以声明函数对象。

Container

在实际的开发过程中，数据结构本身的重要性不会逊于操作于数据结构的算法的重要性，当程序中存在着对时间要求很高的部分时，数据结构的选择就显得更加重要。

经典的数据结构数量有限，但是我们常常重复着一些为了实现向量、链表等结构而编写的代码，这些代码都十分相似，只是为了适应不同数据的变化而在细节上有所出入。STL容器

就为我们提供了这样的方便，它允许我们重复利用已有的实现构造自己的特定类型下的数据结构，通过设置一些模版类，STL容器对最常用的数据结构提供了支持，这些模板的参数

允许我们指定容器中元素的数据类型，可以将我们许多重复而乏味的工作简化。

容器部分主要由头文件 vector, list, deque, set, map, stack、queue组成。对于常用的一些容器和容器适配器（可以看作由其它容器实现的容器），可以通过下表总结一下它们和相应头文件的对应关系。

向量(vector) 连续存储的元素vector。

#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int>vi;
int a;
while(true)
{
cout<<"输入一个整数，按0停止输入：";
cin>>a;
if(a==0)
break;
vi.push_back(a);
vector<int>::iterator iter;
for(iter=vi.begin();iter!=vi.end();++iter)
cout<<*iter;
}
return 0;
}

列表(list) 由节点组成的双向链表，每个结点包含着一个元素 list

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>
using namespace std;
//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;

//创建一个list容器的实例LISTCHAR
typedef list<int> LISTCHAR;

int main(){
//--------------------------
//用list容器处理整型数据
//--------------------------
//用LISTINT创建一个名为listOne的list对象
LISTINT listOne;
//声明i为迭代器
LISTINT::iterator i;

//从前面向listOne容器中添加数据
listOne.push_front (2);
listOne.push_front (1);

//从后面向listOne容器中添加数据
listOne.push_back (3);
listOne.push_back (4);

//从前向后显示listOne中的数据
cout<<"listOne.begin()--- listOne.end():"<<endl;
for (i = listOne.begin(); i != listOne.end(); ++i)
cout << *i << " ";
cout << endl;

//从后向前显示listOne中的数据
LISTINT::reverse_iterator ir;
cout<<"listOne.rbegin()---listOne.rend():"<<endl;
for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
cout << *ir << " ";
}
cout << endl;

//使用STL的accumulate(累加)算法
int result = accumulate(listOne.begin(), listOne.end(),0);
cout<<"Sum="<<result<<endl;
cout<<"------------------"<<endl;

//--------------------------
//用list容器处理字符型数据
//--------------------------

//用LISTCHAR创建一个名为listOne的list对象
LISTCHAR listTwo;
//声明i为迭代器
LISTCHAR::iterator j;

//从前面向listTwo容器中添加数据
listTwo.push_front ('A');
listTwo.push_front ('B');

//从后面向listTwo容器中添加数据
listTwo.push_back ('x');
listTwo.push_back ('y');

//从前向后显示listTwo中的数据
cout<<"listTwo.begin()---listTwo.end():"<<endl;
for (j = listTwo.begin(); j != listTwo.end(); ++j)
cout << char(*j) << " ";
cout << endl;

//使用STL的max_element算法求listTwo中的最大元素并显示
j=max_element(listTwo.begin(),listTwo.end());
cout << "The maximum element in listTwo is: "<<char(*j)<<endl;
}

#include <iostream>
#include <list>

using namespace std;
typedef list<int> INTLIST;

//从前向后显示list队列的全部元素
void put_list(INTLIST list, char *name)
{
INTLIST::iterator plist;

cout << "The contents of " << name << " : ";
for(plist = list.begin(); plist != list.end(); plist++)
cout << *plist << " ";
cout<<endl;
}

//测试list容器的功能
int main(){
//list1对象初始为空
INTLIST list1;
//list2对象最初有10个值为6的元素
INTLIST list2(10,6);
//list3对象最初有9个值为6的元素
INTLIST list3(list2.begin(),--list2.end());

//声明一个名为i的双向迭代器
INTLIST::iterator i;

//从前向后显示各list对象的元素
put_list(list1,"list1");
put_list(list2,"list2");
put_list(list3,"list3");

//从list1序列后面添加两个元素
list1.push_back(2);
list1.push_back(4);
cout<<"list1.push_back(2) and list1.push_back(4):"<<endl;
put_list(list1,"list1");

//从list1序列前面添加两个元素
list1.push_front(5);
list1.push_front(7);
cout<<"list1.push_front(5) and list1.push_front(7):"<<endl;
put_list(list1,"list1");

//在list1序列中间插入数据3个9
list1.insert(++list1.begin(),3,9);
cout<<"list1.insert(list1.begin(),3,9):"<<endl;
put_list(list1,"list1");

//测试引用类函数
cout<<"list1.front()="<<list1.front()<<endl;
cout<<"list1.back()="<<list1.back()<<endl;

//从list1序列的前后各移去一个元素
list1.pop_front();
list1.pop_back();
cout<<"list1.pop_front() and list1.pop_back():"<<endl;
put_list(list1,"list1");

//清除list1中的第2个元素
list1.erase(++list1.begin());
cout<<"list1.erase(++list1.begin()):"<<endl;
put_list(list1,"list1");

//对list2赋值并显示
list2.assign(8,1);
cout<<"list2.assign(8,1):"<<endl;
put_list(list2,"list2");

//显示序列的状态信息
cout<<"list1.max_size(): "<<list1.max_size()<<endl;
cout<<"list1.size(): "<<list1.size()<<endl;
cout<<"list1.empty(): "<<list1.empty()<<endl;

//list序列容器的运算
put_list(list1,"list1");
put_list(list3,"list3");
cout<<"list1>list3: "<<(list1>list3)<<endl;
cout<<"list1<list3: "<<(list1<list3)<<endl;

//对list1容器排序
list1.sort();
put_list(list1,"list1");

//结合处理
list1.splice(++list1.begin(), list3);
put_list(list1,"list1");
put_list(list3,"list3");
}

双队列(deque) 连续存储的指向不同元素的指针所组成的数组 deque

集合(set) 由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序 set

多重集合(multiset) 允许存在两个次序相等的元素的集合 set

栈(stack) 后进先出的值的排列 stack

队列(queue) 先进先出的执的排列 queue

优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 queue

映射(map) 由{键，值}对组成的集合，以某种作用于键对上的谓词排列 map

#include   <stdlib.h>
#include   <windows.h>
#include   <conio.h>
#include   <map>   //STL
#include   <functional> //STL
#include   <algorithm>   //STL
#include   <iostream>

using namespace std;

typedef  map<int,int*> m_iip;
typedef  map<int,char*> m_icp;

class  f_c{
int _i;
public:
f_c(int i):_i(i){

}
void operator()(m_iip::value_type ite)
{
cout<<_i++<<"\t"<<ite.first<<" shi"<<endl;
}
void operator()(m_icp::value_type ite)
{
cout<<_i++<<"\t"<<ite.first<<" yang"<<endl;
}
};
void f(int i,int c)
{

}
int main(int argc,char* argv[]){
m_iip  iip;
m_icp  icp;
int i=0;
iip.insert(make_pair(34,&i));
iip.insert(make_pair(67,&i));
iip.insert(make_pair(5,&i));
iip.insert(make_pair(342,&i));
char d=0;
icp.insert(make_pair(12,&d));
icp.insert(make_pair(54,&d));
icp.insert(make_pair(6,&d));
icp.insert(make_pair(92,&d));
for_each(iip.begin(),iip.end(),f_c(8));
for_each(icp.begin(),icp.end(),f_c(65));//
return 0;
}

多重映射(multimap) 允许键对有相等的次序的映射 map

Iterator

下面要说的迭代器从作用上来说是最基本的部分，可是理解起来比前两者都要费力一些（至少笔者是这样）。软件设计有一个基本原则，所有的问题都可以通过引进一个间接层来简化，这种简化在STL中就是用迭代器来完成的。

概括来说，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎STL提供的所有算法都是通过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。

迭代器部分主要由头文件 utility, iterator 和 memory 组成。

utility 是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，iterator 中提供了迭代器使用的许多方法，而对于 memory 的描述则十分的困难，它以不同寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制, memory中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器。

对于之前不太了解STL的读者来说，上面的文字只是十分概括地描述了一下STL的框架，对您理解STL的机制乃至使用STL所起到的帮助微乎甚微，这不光是因为深入STL需要对C++的高级应用有比较全面的了解，更因为STL的三个部分算法、容器和迭代器三部分是互相牵制或者说是紧密结合的。从概念上讲最基础的部分是迭代器，可是直接学习迭代器会遇到许多抽象枯燥和繁琐的细节，然而不真正理解迭代器又是无法直接进入另两部分的学习的（至少对剖析源码来说是这样）。可以说，适应STL处理问题的方法是需要花费一定的时间的，但是以此为代价，STL取得了一种十分可贵的独立性，它通过迭代器能在尽可能少地知道某种数据结构的情况下完成对这一结构的运算，所以下决心钻研STL的朋友们千万不要被一时的困难击倒。其实STL运用的模式相对统一，只要适应了它，从一个STL工具到另一个工具，都不会有什么大的变化。

head

C++头文件一览
C、传统 C++

#include <assert.h>　　　　设定插入点
#include <ctype.h>　　　　字符处理
#include <errno.h>　　　　 定义错误码
#include <float.h>　　　　浮点数处理
#include <fstream.h>　　　文件输入／输出
#include <iomanip.h>　　　 参数化输入／输出
#include <iostream.h>　　　数据流输入／输出
#include <limits.h>　　　　定义各种数据类型最值常量
#include <locale.h>　　　　定义本地化函数
#include <math.h>　　　　　定义数学函数
#include <stdio.h>　　　　定义输入／输出函数
#include <stdlib.h>　　　　定义杂项函数及内存分配函数
#include <string.h>　　　　字符串处理
#include <strstrea.h>　　　基于数组的输入／输出
#include <time.h>　　　　　定义关于时间的函数
#include <wchar.h>　　　　 宽字符处理及输入／输出
#include <wctype.h>　　　　宽字符分类

标准 C++　

#include <algorithm>　　　  通用算法
#include <bitset>　　　　　  位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>　　　　 复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>　　　　　 双端队列容器
#include <exception>　　　 异常处理类
#include <fstream>
#include <functional>　　　 定义运算函数（代替运算符）
#include <limits>
#include <list>　　　　　　 线性列表容器
#include <map>　　　　　　 映射容器
#include <iomanip>
#include <ios>　　　　　　基本输入／输出支持
#include <iosfwd>　　　　输入／输出系统使用的前置声明
#include <iostream>
#include <istream>　　　　 基本输入流
#include <ostream>　　　　 基本输出流
#include <queue>　　　　　  队列容器
#include <set>　　　　　　 集合容器
#include <sstream>　　　　 基于字符串的流
#include <stack>　　　　　 堆栈容器　　　　
#include <stdexcept>　　　 标准异常类
#include <streambuf>　　　底层输入／输出支持
#include <string>　　　　　字符串类
#include <utility>　　　　 通用模板类
#include <vector>　　　　 动态数组容器
#include <cwchar>
#include <cwctype>

C99 增加

#include <complex.h>　　复数处理
#include <fenv.h>　　　　浮点环境
#include <inttypes.h>　　整数格式转换
#include <stdbool.h>　　 布尔环境
#include <stdint.h>　　　整型环境
#include <tgmath.h>　　通用类型数学宏

List

List Introduction

Efficient insertion and removal of elements anywhere in the container (constant time).

Efficient moving elements and block of elements within the container or even between different containers (constant time).

Iterating over the elements in forward or reverse order (linear time).

Iterating over the elements in forward or reverse order (linear time).

双向链表是一种每个节点都有两个指针，分别直接的指向了直接前驱和直接后驱。

template < class T, class Allocator = allocator<T> > class list;

member：

http://blog.csdn.net/wallwind/article/details/6892139

Using

function usage in detail：

http://www.360doc.com/content/14/0107/09/1317564_343237392.shtml

http://www.360doc.com/content/14/0107/09/1317564_343237529.shtml

assign() 给list赋值

back() 返回最后一个元素

begin() 返回指向第一个元素的迭代器

clear() 删除所有元素

empty() 如果list是空的则返回true

end() 返回末尾的迭代器

erase() 删除一个元素

front() 返回第一个元素

get_allocator() 返回list的配置器

insert() 插入一个元素到list中

max_size() 返回list能容纳的最大元素数量

merge() 合并两个list

pop_back() 删除最后一个元素

pop_front() 删除第一个元素

push_back() 在list的末尾添加一个元素

push_front() 在list的头部添加一个元素

rbegin() 返回指向第一个元素的逆向迭代器

remove() 从list删除元素

remove_if() 按指定条件删除元素

rend() 指向list末尾的逆向迭代器

resize() 改变list的大小

reverse() 把list的元素倒转

size() 返回list中的元素个数

sort() 给list排序

splice() 合并两个list

swap() 交换两个list

unique() 删除list中重复的元素

Template Introduction

#include<iostream>
#include<list>

using namespace std;

int
main(void)
{
int arr[] = {1, 2, 3, 4, 5};
list<int> l(arr, arr + sizeof(arr)/sizeof(int));

// list::front
cout << "Thefirst element is : " << l.front() << endl;
// list::back
cout << "Thesecond element is : " << l.back() << endl;

return(0);
}

http://blog.csdn.net/zhangliang_571/article/details/26143631

http://www.cnblogs.com/rushoooooo/archive/2011/09/03/2164623.html

http://blog.sina.com.cn/s/blog_648debb00100rhgr.html

erase：

http://blog.sina.com.cn/s/blog_782496390100rtyp.html

memory allocation

没有new的 进程虚拟地址空间中的栈中分配内存，使用了new，在堆中分配了内存，而栈中内存的分配和释放是由系统管理，而堆中内存的分配和释放必须由程序员手动释放。

栈是系统数据结构，对于进程/线程是唯一的，它的分配与释放由操作系统来维护，不需要开发者来管理。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时，这些存储单元会被自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，不同的操作系统对栈都有一定的限制。 堆上的内存分配，亦称动态内存分配。程序在运行的期间用malloc申请的内存，这部分内存由程序员自己负责管理，其生存期由开发者决定：在何时分配，分配多少，并在何时用free来释放该内存。这是唯一可以由开发者参与管理的内存。使用的好坏直接决定系统的性能和稳定。

栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率 比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在 堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会 分 到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。

http://zhidao.baidu.com/link?url=H1qujvB9llIwZysgBa7frrFh0OwGNghXD3zVqStIYeTfpPyK448-7XPVrWDq1btd1TaM4UGeNIePvurBOfNX8Lkh7TNcRstkBDzsguqjLIe

http://www.cnblogs.com/Code-life/archive/2009/12/06/1618014.html

http://blog.163.com/shayne_chu/blog/static/167097832201062562723206/

http://www.cnblogs.com/GODYCA/archive/2013/01/10/2854777.html

http://blog.163.com/shayne_chu/blog/static/167097832201062562723206/

example

declaration：
/// list template
template< class C >
class TComList : public std::list< C >
{
public:
typedef typename std::list<C>::iterator TComIterator;

TComList& operator += ( const TComList& rcTComList)
{
if( ! rcTComList.empty() )
{
insert( this->end(), rcTComList.begin(), rcTComList.end());
}
return *this;
} // leszek

C popBack()
{
C cT = this->back();
this->pop_back();
return cT;
}

C popFront()
{
C cT = this->front();
this->pop_front();
return cT;
}

Void pushBack( const C& rcT )
{
/*assert( sizeof(C) == 4);*/
if( rcT != NULL )
{
this->push_back( rcT);
}
}

Void pushFront( const C& rcT )
{
/*assert( sizeof(C) == 4);*/
if( rcT != NULL )
{
this->push_front( rcT);
}
}

TComIterator find( const C& rcT ) // leszek
{
return find( this->begin(), this->end(), rcT );
}
};

/// picture class (symbol + YUV buffers)
class TComPic
{
public:
UInt                  m_uiTLayer;               //  Temporal layer
Bool                  m_bUsedByCurr;            //  Used by current picture
Bool                  m_bIsLongTerm;            //  IS long term picture
Bool                  m_bIsDecoded;             //  IS the Pic decode end
TComPicSym*           m_apcPicSym;              //  Symbol

TComPicYuv*           m_apcPicYuv[2];           //  Texture,  0:org / 1:rec

TComPicYuv*           m_pcPicYuvPred;           //  Prediction
TComPicYuv*           m_pcPicYuvResi;           //  Residual
Bool                  m_bReconstructed;
Bool                  m_bNeededForOutput;
UInt                  m_uiCurrSliceIdx;         // Index of current slice
Int*                  m_pSliceSUMap;
Bool*                 m_pbValidSlice;
Int                   m_sliceGranularityForNDBFilter;
Bool                  m_bIndependentSliceBoundaryForNDBFilter;
Bool                  m_bIndependentTileBoundaryForNDBFilter;
TComPicYuv*           m_pNDBFilterYuvTmp;    //!< temporary picture buffer when non-cross slice/tile boundary in-loop filtering is enabled
Bool                  m_bCheckLTMSB;

Int                   m_numReorderPics[MAX_TLAYER];
Window                m_conformanceWindow;
Window                m_defaultDisplayWindow;

bool                  m_isTop;
bool                  m_isField;

std::vector<std::vector<TComDataCU*> > m_vSliceCUDataLink;

SEIMessages  m_SEIs; ///< Any SEI messages that have been received.  If !NULL we own the object.
Int                   idx;

public:
TComPic();
virtual ~TComPic();

Void          create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, Window &conformanceWindow, Window &defaultDisplayWindow,
Int *numReorderPics, Bool bIsVirtual = false );

virtual Void  destroy();

void          setIdx(Int s)                { idx=s; }
Int           getIdx()                     { return idx; }
UInt          getTLayer()                { return m_uiTLayer;   }
Void          setTLayer( UInt uiTLayer ) { m_uiTLayer = uiTLayer; }
Void          setDecoded(Bool b)          { m_bIsDecoded = b;   }
Bool          getDecoded()                { return m_bIsDecoded;}
Bool          getUsedByCurr()             { return m_bUsedByCurr; }
Void          setUsedByCurr( Bool bUsed ) { m_bUsedByCurr = bUsed; }
Bool          getIsLongTerm()             { return m_bIsLongTerm; }
Void          setIsLongTerm( Bool lt ) { m_bIsLongTerm = lt; }
Void          setCheckLTMSBPresent     (Bool b ) {m_bCheckLTMSB=b;}
Bool          getCheckLTMSBPresent     () { return m_bCheckLTMSB;}

TComPicSym*   getPicSym()           { return  m_apcPicSym;    }
TComSlice*    getSlice(Int i)       { return  m_apcPicSym->getSlice(i);  }
Int           getPOC()              { return  m_apcPicSym->getSlice(m_uiCurrSliceIdx)->getPOC();  }
TComDataCU*&  getCU( UInt uiCUAddr )
{
return  m_apcPicSym->getCU( uiCUAddr );
}

TComDataCU_hm*  getCU_hm( UInt uiCUAddr )  { return  NULL; }
TComPicYuv*   getPicYuvOrg()        { return  m_apcPicYuv[0]; }
TComPicYuv*   getPicYuvRec()        { return  m_apcPicYuv[1]; }

TComPicYuv*   getPicYuvPred()       { return  m_pcPicYuvPred; }
TComPicYuv*   getPicYuvResi()       { return  m_pcPicYuvResi; }
Void          setPicYuvPred( TComPicYuv* pcPicYuv )       { m_pcPicYuvPred = pcPicYuv; }
Void          setPicYuvResi( TComPicYuv* pcPicYuv )       { m_pcPicYuvResi = pcPicYuv; }

UInt          getNumCUsInFrame()      { return m_apcPicSym->getNumberOfCUsInFrame(); }
UInt          getNumPartInWidth()     { return m_apcPicSym->getNumPartInWidth();     }
UInt          getNumPartInHeight()    { return m_apcPicSym->getNumPartInHeight();    }
UInt          getNumPartInCU()        { return m_apcPicSym->getNumPartition();       }
UInt          getFrameWidthInCU()     { return m_apcPicSym->getFrameWidthInCU();     }
UInt          getFrameHeightInCU()    { return m_apcPicSym->getFrameHeightInCU();    }
UInt          getMinCUWidth()         { return m_apcPicSym->getMinCUWidth();         }
UInt          getMinCUHeight()        { return m_apcPicSym->getMinCUHeight();        }

UInt          getParPelX(UChar uhPartIdx) { return getParPelX(uhPartIdx); }
UInt          getParPelY(UChar uhPartIdx) { return getParPelX(uhPartIdx); }

Int           getStride()           { return m_apcPicYuv[1]->getStride(); }
Int           getCStride()          { return m_apcPicYuv[1]->getCStride(); }

Void          setReconMark (Bool b) { m_bReconstructed = b;     }
Bool          getReconMark ()       { return m_bReconstructed;  }
Void          setOutputMark (Bool b) { m_bNeededForOutput = b;     }
Bool          getOutputMark ()       { return m_bNeededForOutput;  }

Void          setNumReorderPics(Int i, UInt tlayer) { m_numReorderPics[tlayer] = i;    }
Int           getNumReorderPics(UInt tlayer)        { return m_numReorderPics[tlayer]; }

Void          compressMotion();
UInt          getCurrSliceIdx()            { return m_uiCurrSliceIdx;                }
Void          setCurrSliceIdx(UInt i)      { m_uiCurrSliceIdx = i;                   }
UInt          getNumAllocatedSlice()       {return m_apcPicSym->getNumAllocatedSlice();}
Void          allocateNewSlice()           {m_apcPicSym->allocateNewSlice();         }
Void          clearSliceBuffer()           {m_apcPicSym->clearSliceBuffer();         }

Window&       getConformanceWindow()  { return m_conformanceWindow; }
Window&       getDefDisplayWindow()   { return m_defaultDisplayWindow; }

Void          createNonDBFilterInfo   (std::vector<Int> sliceStartAddress, Int sliceGranularityDepth
,std::vector<Bool>* LFCrossSliceBoundary
,Int  numTiles = 1
,Bool bNDBFilterCrossTileBoundary = true);
Void          createNonDBFilterInfoLCU(Int tileID, Int sliceID, TComDataCU* pcCU, UInt startSU, UInt endSU, Int sliceGranularyDepth, UInt picWidth, UInt picHeight);
Void          destroyNonDBFilterInfo();

Bool          getValidSlice                                  (Int sliceID)  {return m_pbValidSlice[sliceID];}
Bool          getIndependentSliceBoundaryForNDBFilter        ()             {return m_bIndependentSliceBoundaryForNDBFilter;}
Bool          getIndependentTileBoundaryForNDBFilter         ()             {return m_bIndependentTileBoundaryForNDBFilter; }
TComPicYuv*   getYuvPicBufferForIndependentBoundaryProcessing()             {return m_pNDBFilterYuvTmp;}
std::vector<TComDataCU*>& getOneSliceCUDataForNDBFilter      (Int sliceID) { return m_vSliceCUDataLink[sliceID];}

/* field coding parameters*/

Void              setTopField(bool b)                  {m_isTop = b;}
bool              isTopField()                         {return m_isTop;}
Void              setField(bool b)                     {m_isField = b;}
bool              isField()                            {return m_isField;}

/** transfer ownership of seis to this picture */
void setSEIs(SEIMessages& seis) { m_SEIs = seis; }

/**
* return the current list of SEI messages associated with this picture.
* Pointer is valid until this->destroy() is called */
SEIMessages& getSEIs() { return m_SEIs; }

/**
* return the current list of SEI messages associated with this picture.
* Pointer is valid until this->destroy() is called */
const SEIMessages& getSEIs() const { return m_SEIs; }

};// END CLASS DEFINITION TComPic

definition：
TComList<TComPic*>* pcListPic = NULL;