map与vector,typedef与define

allocator_type	在 vector中使用的分配器类型。.
const_iterator	用于遍历vector 的常量(随机访问)迭代器
const_pointer	元素的常量指针类型。
const_reference	元素的常量引用类型。
const_reverse_iterator	用于反向遍历 vector 的常量迭代器。
difference_type	距离类型。(用于表示两个迭代器间距离的有符号整数类型)
iterator	用于遍历vector 的(随机访问)迭代器
pointer	元素的指针类型。
reference	元素的引用类型。
reverse_iterator	用于反向遍历vector的迭代器。
size_type	大小类型。(用于表示容器距离类型的任一非负值的无符号整数类型)
value_type	保存在 vector中的元素的类型。

Member Functions

assign	赋值 n 个 items 到vector中。
at	取得位于 index 位置的元素。
back	取得最后一个元素。
begin	取得指向vector头部的迭代器。
capacity	取得vector的容量。
clear	删除vector中的所有元素
empty	vector是否为空？
end	取得指向 vector尾部的迭代器。
erase	删除指定位置的一个或多个元素。
front	取得第一个元素。
get_allocator	取出分配器。
insert	在指定位置插入一个元素。
max_size	取得 vector 的最大可能大小或容量(取决于分配器的 max_size())。
pop_back	从vector中删除最后一个元素。
push_back	插入一个新元素到vector的末端。
rbegin	取得指向"反向"vector头部的迭代器。
rend	取得指向"反向" vector 的尾部的迭代器。
resize	修改vector的大小。
reserve	取得可以插入到 vector中而不覆写任何已存元素的最大元素数量。
size	取得当前保存在vector 中的元素数量。
swap	交换两个vector的内容。

2.1 定义和初始化

Ø vector< typeName > v1;

默认v1为空，故下面的赋值是错误的v1[0]=5;

Ø vector<typeName>v2(v1);

v2=v1;即： v2是v1的拷贝

Ø vector<typeName> v2(v1.begin(), v1.end());

v2是v1的一个副本，若v1.size（）>v2.size()则赋值后v2.size()被扩充为v1.size()。

Ø vector< typeName > v3(n,i);

v3包含n个值为i的typeName类型元素

Ø vector< typeName > v4(n);

v4含有n个值为0的元素

Ø int a[4]={0,1,2,3,3}; vector<int> v5(a,a+5);

v5的size为5，v5被初始化为a的5个值。后一个指针要指向将被拷贝的末元素的下一位置。

Ø vector<int> v6(v5);

v6是v5的拷贝
vector< 类型 > 标识符（最大容量，初始所有值）；

2.2 值初始化

1>     如果没有指定元素初始化式，标准库自行提供一个初始化值进行值初始化。
2>     如果保存的式含有构造函数的类类型的元素，标准库使用该类型的构造函数初始化。
3>     如果保存的式没有构造函数的类类型的元素，标准库产生一个带初始值的对象，使用这个对象进行值初始化。

2.3 vector对象最重要的几种函数

2.3.1 v.push_back(t)

在容器的最后添加一个值为t的数据，容器的size变大。

另外list有push_front()函数，在前端插入，后面的元素下标依次增大。

2.3.2 v.size()

返回容器中数据的个数，size返回相应vector类定义的size_type的值。

2.3.3 v.empty()

判断vector是否为空

2.3.4 v[n]

返回v中位置为n的元素

2.3.5 v.insert(pointer,number, content)

向v中pointer指向的位置插入number个content的内容。

2.3.6 v.pop_back()

删除容器的末元素，并不返回该元素。

2.3.7 v.erase(pointer1,pointer2)

删除pointer1到pointer2中间（包括pointer1所指）的元素。vector中删除一个元素后，此位置以后的元素都需要往前移动一个位置，虽然当前迭代器位置没有自动加1，但是由于后续元素的顺次前移，也就相当于迭代器的自动指向下一个位置一样。

2.3.8 vector<typeName>::iterator p=v1.begin( );

p初始值指向v1的第一个元素。*p取所指向元素的值。对于const vector<typeName>只能用vector<typeName>::const_iterator类型的指针访问。

2.3.9 p=v1.end( );

p指向v1的最后一个元素的下一位置。

2.3.10 v.clear()

删除容器中的所有元素。

2.4 vector的其他成员函数

Ø c.assign(beg,end)
将[beg; end)区间中的数据赋值给c。

Ø c.assign(n,elem)
将n个elem的拷贝赋值给c。

Ø c.at(idx)
传回索引idx所指的数据，如果idx越界，抛出out_of_range。

Ø c.back()
传回最后一个数据，不检查这个数据是否存在。

Ø c.front()
传回地一个数据。

Ø get_allocator
使用构造函数返回一个拷贝。

Ø c.rbegin()
传回一个逆向队列的第一个数据。

Ø c.rend()
传回一个逆向队列的最后一个数据的下一个位置。

Ø c.~ vector <Elem>()
销毁所有数据，释放内存。

3 map Members

Typedefs

allocator_type	表示为map对象分配器类。
const_iterator	可提供双向迭代器，可以读取在map中的常量元素。
const_pointer	在map中提供一个指向一个常量元素
const_reference	可提供一个存储在map中常量元素引用，用于阅读和执行常量操作。
const_reverse_iterator	可提供双向迭代器，可以读取任何map中常量元素。
difference_type	一个有符号整数类型，可以用来代表一个map中所指向的元素之间的迭代器的一些元素。
iterator	可提供双向迭代器，可以阅读或修改map上的任何元素。
key_compare	一个类型，提供了一个函数对象，可以比较两个排序键，以确定两个map元素的相对顺序
key_type	描述对象的排序键，构成map的每个元素
mapped_type	表示存储在一张map中的数据类型。
pointer	提供在一个在map中指向常量元素的指针
reference	提供了在map上存储一个元素的引用
reverse_iterator	可提供双向迭代器，可以读取或修改反向map中的一个元素。
size_type	一个无符号整数类型，可以代表一个map的元素数
value_type	提供了一个函数对象，可以比较两个key要素的排序，以确定在map上的相对顺序。

Member Functions

begin		返回一个迭代器处理在map的第一个元素。
clear		清除map中所有元素
count		返回map中与指定key匹配的元素的个数
empty		测试如果map是空的。
end		返回一个定位在map中最后一个元素的迭代器。
equal_range		返回由lower_bound和upper_bound返回值构成的pair,也就是所有等价元素区间。
erase		删除map中指定位置的一个元素或者一组元素，或删除与指定的关键字相匹配的元素
find		返回与指定的key相匹配元素的一个迭代器
get_allocator		返回用于构建map的一个分配器的副本
insert		在指定位置向map中插入一个元素或一系列的元素。
key_comp		用于对两个键进行比较。
lower_bound		返回一个迭代器，指向map中键值>=key的第一个元素。例如：{1，3，4，5，6}；lower_bound(2)=3, lower_bound(3)=3
map		构造一个列表,大小、特定值或特定的分配器作为map的副本内容。
max_size		返回map的最大长度。
rbegin		返回一个迭代器，处理反向map的第一个元素。
rend		返回一个迭代器，处理在反向map的最后一个元素
size		返回map中的元素个数。
swap		交换两个map的内容。
upper_bound		返回一个迭代器，指向map中键值>key第一个位置。例如：{1，3，4，5，6}； upper_bound(2)=3,upper_bound(3)=4
value_comp		返回一个比较元素的value
	Standard C++ Library Reference

3.1 erase

3.1.1 原型

作用：删除map中指定位置的一个元素或者一组元素，或删除与指定的关键字相匹配的元素。

Ø         iterator erase(iterator _Where);

//where为map中被移除的元素位置

Ø         iterator erase( iterator _First, iterator _Last);

//First:从map删除第一个元素的位置

//Last: 从map删除最后一个元素的位置

Ø         size_type erase( const key_type& _Key);

//从map中删除的元素的关键字值，返回已被从地图中删除元素的数量

3.1.2 例子

#include <map>

#include <iostream>

int main( )

   using namespace std;

   map <int, int> m1, m2, m3;

   map <int, int> :: iterator pIter, Iter1, Iter2;

   int i, n;

   typedef pair <int, int> Int_Pair;

   for ( i = 1 ; i < 5 ; i++ )

      m1.insert ( Int_Pair ( i, i ) );

      m2.insert ( Int_Pair ( i, i*i ) );

      m3.insert ( Int_Pair ( i, i-1 ) );

   // The 1st member function removes an element at a given position

   Iter1 = ++m1.begin( );

   m1.erase( Iter1 );

   cout << "After the 2nd element is deleted, the map m1 is:" ;

   for ( pIter = m1.begin( ) ; pIter != m1.end( ) ; pIter++ )

      cout << " " << pIter -> second;

   cout << "." << endl;

   // The 2nd member function removes elements

   // in the range [_First, _Last)

   Iter1 = ++m2.begin( );

   Iter2 = --m2.end( );

   m2.erase( Iter1, Iter2 );

   cout << "After the middle two elements are deleted,"

        << " the map m2 is:" ;

   for ( pIter = m2.begin( ) ; pIter != m2.end( ) ; pIter++ )

      cout << " " << pIter -> second;

   cout << "." << endl;

   // The 3rd member function removes elements with a given _Key

   n = m3.erase( 2 );

   cout << "After the element with a key of 2 is deleted,\n"

        << "the map m3 is:" ;

   for ( pIter = m3.begin( ) ; pIter != m3.end( ) ; pIter++ )

      cout << " " << pIter -> second;

   cout << "." << endl;

   // The 3rd member function returns the number of elements removed

   cout << "The number of elements removed from m3 is: "

        << n << "." << endl;

   // The dereferenced iterator can also be used to specify a key

   Iter1 = ++m3.begin( );

   m3.erase( Iter1 );

   cout << "After another element with a key equal to that"

        << endl;

   cout  << "of the 2nd element is deleted, "

         << "the map m3 is:" ;

   for ( pIter = m3.begin( ) ; pIter != m3.end( ) ; pIter++ )

      cout << " " << pIter -> second;

   cout << "." << endl;

输出结果：

After the 2nd element is deleted, the map m1 is: 1 3 4.

After the middle two elements are deleted, the map m2 is: 1 16.

After the element with a key of 2 is deleted,

the map m3 is: 0 2 3.

The number of elements removed from m3 is: 1.

After another element with a key equal to that

of the 2nd element is deleted, the map m3 is: 0 3.See Also

3.2 find

3.2.1 原型

Ø         iterator find(const Key& _Key);

Ø         const_iterator find(const Key& _Key) const;

3.2.2 例子

#include <map>

#include <iostream>

int main( )

{

using namespace std;

map <int, int> m1;

map <int, int> :: const_iterator m1_AcIter, m1_RcIter;

typedef pair <int, int> Int_Pair;

m1.insert ( Int_Pair ( 1, 10 ) );

m1.insert ( Int_Pair ( 2, 20 ) );

m1.insert ( Int_Pair ( 3, 30 ) );

m1_RcIter = m1.find( 2 );

cout << "The element of map m1 with a key of 2 is: "

<< m1_RcIter -> second << "." << endl;

// If no match is found for the key, end( ) is returned

m1_RcIter = m1.find( 4 );

if ( m1_RcIter == m1.end( ) )

cout << "The map m1 doesn't have an element "

<< "with a key of 4." << endl;

else

cout << "The element of map m1 with a key of 4 is: "

<< m1_RcIter -> second << "." << endl;

// The element at a specific location in the map can be found

// using a dereferenced iterator addressing the location

m1_AcIter = m1.end( );

m1_AcIter--;

m1_RcIter = m1.find( m1_AcIter -> first );

cout << "The element of m1 with a key matching "

<< "that of the last element is: "

<< m1_RcIter -> second << "." << endl;

}

结果

The element of map m1 with a key of 2 is: 20.

The map m1 doesn't have an element with a key of 4.

The element of m1 with a key matching that of the last element is: 30.

3.3 clear

3.3.1 作用：

作用：清除所有map中的元素

3.3.2 例子

#include <map>

#include <iostream>

int main( )

{

using namespace std;

map <int, int> m1;

int i;

typedef pair <int, int> Int_Pair;

m1.insert ( Int_Pair ( 1, 1 ) );

m1.insert ( Int_Pair ( 2, 4 ) );

i = m1.size( );

cout << "The size of the map is initially " << i << "." << endl;

m1.clear( );

i = m1.size( );

cout << "The size of the map after clearing is " << i << "." << endl;

}

输出结果：

The size of the map is initially 2.

The size of the map after clearing is 0.

3.4 end

3.4.1 作用：

返回一个迭代器，成功解决了定位在map的最后一个元素

3.4.2 例子

#include <map>

#include <iostream>

int main( )

{

using namespace std;

map <int, int> m1;

int i;

map <int, int> :: iterator m1_Iter;

map <int, int> :: const_iterator m1_cIter;

typedef pair <int, int> Int_Pair;

m1.insert ( Int_Pair ( 1, 10 ) );

m1.insert ( Int_Pair ( 2, 20 ) );

m1.insert ( Int_Pair ( 3, 30 ) );

m1_cIter = m1.end( );

m1_cIter--;

cout << "The value of the last element of m1 is:\n" << m1_cIter -> second << endl;

m1_Iter = m1.end( );

m1_Iter--;

m1.erase ( m1_Iter );

// The following 2 lines would err because the iterator is const

// m1_cIter = m1.end ( );

// m1_cIter--;

// m1.erase ( m1_cIter );

m1_cIter = m1.end( );

m1_cIter--;

cout << "The value of the last element of m1 is now:\n" << m1_cIter -> second << endl;

}

Output

The value of the last element of m1 is:

The value of the last element of m1 is now:

4 #pragma once什么作用

#pragma once什么作用是：保证头文件被编译一次,为了保证效率

5 . extern "C" __declspec(dllexport)

#ifndef MXVFUNCDLL_EXPORT

#define MXVFUNCDLL_EXPORT extern "C" __declspec(dllexport)

#endif

Ø 加extern "C "是为了说明使用的C风格的命名方式

Ø __declspec(dllexport)从 DLL 导出数据、函数、类或类成员函数。

其实def文件的功能相当于extern “C” __declspec(dllexport)

6 类型转化

Ø #ifndef _ATSSCHEME_H_

#define _ATSSCHEME_EXT_CLASS AFX_CLASS_IMPORT

#else

#define _ATSSCHEME_EXT_CLASS AFX_CLASS_EXPORT

#endif

Ø class _ATSSCHEME_EXT_CLASS CATSSchemeItem : public CATSSchemeBase

Ø CATSSchemeBase* pSchemeItem

Ø CATSSchemeItem* pItem

如果把CATSSchemeBase 类型的指针pSchemeItem 转化为子类CATSSchemeItem类型的指针，则CATSSchemeItem* pItem = dynamic_cast<CATSSchemeItem*>(pSchemeItem);

7 delete

char*ch1;
ch1=new char('h');
delete ch1;

Ø
delete一个指针，系统只是将指针指向的堆空间回收，但是没有将指针变量的值赋值为null。也就是说指针还是指向原来的堆空间，但是这个空间已经失效。
所以delete一个指针以后要马上将它赋值为null，不然容易导致野指针的出现。。。

Ø 用delete ch1是可以把ch1指向的堆空间释放，但ch1指向的堆空间还是存在的（内存空间始终存在的，只是你程序用不到这段内存），也就是说这一快内存没有被你这段程序运用，当你再new的时候，有可能还会申请到这块内存，所以如再调用这段内存可能会发生不可预知的情况，所以一般delete之后就把指针设为NULL。