《C++标准程序库》学习笔记9 — 第十一章

这一章讲的是string类型,内容很多,但是不难,都是一些string的成员,需要记住用法。

  • 1.(P474)

和C-string不同,string对象的字符串皆为并没有特殊字符‘\0’

 

  • 2.(P474)

在搜寻string时,如果失败,则返回一个特殊值npos,在检验返回值是否是npos时,应该用string::size_type类型去比较,而不是int或unsigned int。

size_type是一个不带正负号的整数型别。要注意类型之间的转换,不要试图拿size_type与int比较,当int变量为0时,size_type任何变量都比0大。(P476例二)

npos只是一个表示返回失败的特殊值,并不是string的长度。

 

  • 3.(P483)

在string的构造函数中:

string s(str, stridx)

表示将字符串str内”始于位置stridx”的部分,当做字符串s的初值

string s(chars, chars_len)

表示以C-string chars的chars_len个字符为字符串s的初值

注意这两个的区别

 

  • 4.(P484)

data()和c_str()返回的字符数组由该字符串本身拥有,所以不要修改它或释放其内存,否则导致字符数组无效。

 

本章其余都是需要记忆的东西,首先得学会用,然后慢慢的用多了,自然就记住了。

《C++标准程序库》学习笔记8 — 第十章

这一章讲了三种容器配接器(container adapter)(Stack, Queue, Priority queue) 和 bitset的特殊容器。

  • 1.

配接器:
一种用来修饰容器(Containers)或仿函数(Functors)或迭代器(Iterators)接口的东西。
例如:STL提供的Queue和Stack,虽然看似容器,其实只能算是一种容器配接器,因为 它们的底部完全借助Deque,所有操作有底层的Deque供应。改变Functor接口者,称为Function Adapter;改变Container接口者,称为Container Adapter;改变Iterator接口者,称为Iterator Adapter。

 

  • 2.(P435)

Stack(栈)
class stack<>实作出了一个stack,可以让我们直接使用LIFO的栈。
使用stack<>要加入头文件:

1
#include <stack>

在头文件<stack>中,class stack定义如下:

1
2
3
4
namespace std {
    template <class T, class Container = deque<T> >
    class stack;
}

带一个template参数代表元素型别,带有默认值的第二个template参数定义stack内部存放元素所用的实际容器,缺省采用queue.

下面使用vector来容纳元素:

1
stack<int, vector<int> > st;

stack的内部接口图:
stack1

 

  • 3.(P446)

自定义的Stack Class
改变了两点:
①.pop()会返回下一个元素(即被删除元素)
②.如果栈为空,则pop()和top()会抛出异常

stack.h头文件:

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
#ifndef STACK_H
#define STACK_H
 
#include <deque>
#include <exception>
 
template <class T>
class Stack{
protected:
    std::deque<T> c;   // container for the elements
 
public:
    class ReadEmptyStack : public std::exception {
    public:
        virtual const char* what() const throw() {
            return “read empty stack”;
        }
    };
 
    typename std::deque<T>::size_type size() const {
        return c.size();
    }
 
    bool empty() const {
        return c.empty();
    }
 
    void push(const T& elem) {
        c.push_back(elem);
    }
 
    T pop() {
        if(c.empty()) {
            throw ReadEmptyStack();
        }
        T elem(c.back());
        c.pop_back();
        return elem;
    }
 
    T& top() {
        if(c.empty()) {
            throw ReadEmptyStack();
        }
        return c.back();
    }
};
 
#endif

 
main.cpp文件:

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
#include <iostream>
#include <string>
#include <set>
#include <vector>
#include <list>
#include <algorithm>
#include “stack.h”
using namespace std;
 
int main()
{
    try {
        Stack<int> st;
 
        st.push(1);
        st.push(2);
        st.push(3);
 
        cout << st.top() << endl;
        st.pop();
        cout << st.top() << endl;
        st.pop();
 
        st.top() = 77;
        st.push(4);
        st.push(5);
 
        st.pop();
 
        cout << st.pop() << ‘ ‘;
        cout << st.pop() << endl;
        cout << st.pop() << endl;
    }
    catch(const exception& e) {
        cerr << “EXCEPTION:<< e.what() << endl;
    }
}

这个程序在stack的异常类编写时,注意what不再抛出任何异常,用了throw(),否则容易导致错误。
我在CSDN上求助过这个问题:
http://topic.csdn.net/u/20110129/16/280fddaa-2ece-4260-9bcf-dbd14afc91f5.html?74553862
http://www.360doc.com/content/10/1215/21/1066008_78498762.shtml

 

  • 4.(P444)

Queue(队列)
Class queue<>实作出一个queue(FIFO)。
queue和上面讲的stack基本类似。
使用queue<>要加入头文件:

1
#include <queue>

在头文件<queue>中,class queue定义如下:

1
2
3
4
namespace std {
    template <class T, class Container = deque<T> >
    class queue;
}

带一个template参数代表元素型别,带有默认值的第二个template参数定义queue内部存放元素所用的实际容器,缺省采用queue.
 
queue的内部接口图:
queue
queue的自定义版本类似stack,只需要在pop()时由pop_back()改成pop_front()即可。

 

  • 5.(P453)

Priority Queue(优先队列)
class priority_queue<> 实作出一个queue,其元素根据优先级被读取,和queue的接口非常类似。只不过他的”下一个元素”不是最先插入的元素,而是”优先级”最高的元素。也就是说,priority_queue里的元素按照指定的规则已经进行了排序。

缺省是按operator<进行升序排列,但如果同时存在若干数值最大的元素,则无法确定下一个元素是若干最大元素中的哪一个。
Priority Queue和一般的queue都定义在头文件<queue>中:

1
#include <queue>

在头文件<queue>中,Priority Queue的定义如下:

1
2
3
4
5
6
namespace std {
    template <class T,
              class Container = vector<T>,
              class Compare = less<typename Container::value_type> >
    class priority_queue;
}

注意这里的缺省容器不再是deque了,而是vector。
带有默认值的第三个template之处了”用以搜寻下一个最高优先元素”的排序准则。缺省是operator<。
eg.下面定义一个逆向(降序的)priority queue:

1
priority_queue<float, vector<float>, greater<float> > buffer;

随便写了一个小程序:

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
// Author: Tanky Woo
// Blog:    www.WuTianQi.com
#include <iostream>
#include <string>
#include <set>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <queue>
using namespace std;
 
int main()
{
    vector<int> vec1;
    vector<int> vec2;
    for(int i=1; i<=9; ++i)
        vec1.push_back (i);
 
    for(int i=1; i<=9; ++i)
        vec2.push_back (i+10);
 
    // 注意这里的用法.
    priority_queue<int, vector<int>, greater<int> > st(vec1.begin(), vec1.end(), greater<int>() , vec2);
    while(!st.empty())
    {
        cout << st.top() << ” “;
        st.pop();
    }
}

 

  • 6.(P460)

Bitset
bitset的优点在于可容纳任意个数的位,但是不能改变状态,如果需要一个可变长度的位容器,则可以选择vector<bool>。
Class bitset定义于头文件<bitset>中。

1
#include <bitset>

bitset的定义:

1
2
3
4
namespace std {
    template <size_t Bits>
    class bitset;
}

bitset的初始化:

bitset<n> b; 
b有n位,每位都为0

bitset<n> b(u); 
b是unsigned long型u的一个副本

bitset<n> b(s); 
b是string对象s中含有的位串的副本

bitset<n> b(s, pos, n); 
b是s中从位置pos开始的n个位的副本

注:
string对象和bitset对象之间是反向转化的:string对象的最右边字符(即下标最大的那个字符)用来初始化bitset对象的低阶位(即下标为0的位)。当用string对象初始化bitset对象时,记住这一差别很重要。

但是,如果直接输出bitset变量,其顺序又和string一样。
eg:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <string>
#include <set>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <queue>
#include <bitset>
using namespace std;
 
int main()
{
    string s(0011001101);
    bitset<10> t(s);
    // 直接输出
    cout << t << endl;
 
    // 从低位到高位输出
    for(int i=0; i<10; ++i)
        cout << t[i];
    cout << endl;
}

输出结果:
0011001101
1011001100

 
bitset提供的函数很多,常用有下面几个。
any() 如果有任何一个位被设置就返回true
count() 返回被设置的位的个数
flip() 反转bits中的位
none() 如果没有位被设置则返回true
reset() 清空所有位
set() 设置位
size() 返回可以容纳的位的个数
test() 返回指定位的状态
to_string() 返回bitset的字符串表示
to_ulong() 返回bitset的整数表示

VS2008解决“没有找到MSVCP90D.dll…”的问题

刚换的硬盘,今天使用VS2008,出现“没有找到MSVCP90D.dll…”的问题,百度了以下,找到以下几个解决方法:

1. 本质问题,是磁盘格式的问题,FAT32的就有问题,改成NTFS就OK了。
把FAT32转NTFS有两种方法:
①.cmd命令:convert X:/FS:NTFS (X表示磁盘,比如D盘就把X改成D)
②.用分区工具

2. Same problem MSCVP90D.dill not found,
went to “Project | Game Properties | Configuration Properties | C/C++ | Code Generation | Runtime Library”
and set Multi-threaded Debug (/MTd),did build generated error messages…
then reset
“Project | Game Properties | Configuration Properties | C/C++ | Code Generation | Runtime Library”
to Multi-threaded Debug DLL (/MDd)!
这是官方的一个方法。

3. 修改工程项目属性—清单工具—输入与输出—嵌入清单—否!

我先用了第3个方法成功,不过不喜欢除C盘以外的盘符是FAT32的,于是我又用cmd命令把我的D盘改成NTFS格式了。一会就好。

顺便说下,
①.在使用cmd命令后,会出现这个提示:
输入驱动器的当前卷标
卷标就是磁盘名称,比如我D盘放的软件,我把D盘名称改成了”软件”,那么我填软件就OK了,不过最好还是改成英文的,怕对中文支持不好,会导致死机。。。

②.FAT32转NTFS不会导致数据丢失,除非死机。
NTFS转FAT32会导致数据丢失。

《C++标准程序库》学习笔记6 — 第八章

这一章讲的是仿函数(Functor),大陆叫函子(咋听起来那么别扭。。。),需要把第五章的仿函数部分看明白。

  • 1.(P124)

仿函数的基础:
行为类似函数,从实现的角度来看,仿函数是一种重载了Operator()的Class 或 Class Template。一般函数指针可视为狭义的仿函数。

函数行为:指可以”使用小括号传递参数,藉以调用某个东西”, eg. function(arg1, arg2)。

如果希望对象也可以这样,可以通过重载”()”操作符(operator() ),并给予合适的参数型别:

1
2
3
4
5
6
class X{
public:
    // define "function call" operator
    return-type operator() (arguements) const;
    ...
};

现在,就可以把这个对象当做函数调用了”

1
2
3
X tk;
...
tk(arg1, arg2);

上述调用等价于:

1
tk.operator() (arg1, arg2);
  • 2.(P125)

入门级的仿函数程序,可以更清楚的理解神马是仿函数。

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
#include <iostream> 
#include <string> 
#include <set> 
#include <vector> 
#include <algorithm> 
using namespace std; 
 
class PrintInt 
{ 
public: 
    void operator() (int elem) const { 
        cout << elem << " "; 
    } 
}; 
 
int main() 
{ 
    vector<int> coll; 
 
    for(int i=1; i<=9; ++i) 
        coll.push_back(i); 
 
    for_each(coll.begin(), coll.end(), PrintInt());   // ———- ① 
    cout << endl; 
    return 0; 
}
  • 3.(P128)

仿函数的优点:
①.仿函数可以拥有自己的状态(state),所以比一般函数更灵巧。
②.仿函数都有其型别。
③.执行速度上,仿函数比函数指针更快。

在编译期间像函数传递参数,可以使用模板,但是模板必须是常量。这时,可以选择用仿函数。
具体对比P(128)~P(129)的两个例子。

  • 4.(P294)

对于仿函数的个人理解:
仿函数就是一个类,而使用仿函数使其模拟函数行为就是利用类对象的()操作符,即调用Class()。
要使用仿函数的operator(),可以选择建一个临时对象或者普通的类对象。
建临时对象如上述第二点中的代码中,注意为①的那一行。
PrintInt()是建立一个临时仿函数对象。
当然,也可以选择:

1
2
PrintInt prin();
for_each(coll.begin(), coll.end(), prin);   //这样就容易理解一些。

关于更多对仿函数对象使用的讨论,可以看我在CSDN上的求助帖:
http://topic.csdn.net/u/20110129/00/1a9db6ac-a65e-460b-aaaa-554e2bdf6450.html?seed=1711992303&r=71476802

  • 5.(P298)

将仿函数以passed by reference方式传递。
这样就可以改变仿函数的状态。

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
// print.h 
#include <iostream> 
using namespace std; 
 
template <class T> 
inline void PRINT_ELEMENTS(const T& coll, const char* optcstr="") 
{ 
    typename T::const_iterator pos; 
    cout << optcstr; 
    for(pos=coll.begin(); pos!=coll.end(); ++pos) 
        cout << *pos << ‘ ‘; 
    cout << endl; 
}
 
 
 
// main.cpp
#include <iostream> 
#include <string> 
#include <set> 
#include <vector> 
#include <list> 
#include <algorithm> 
#include "print.h" 
using namespace std; 
 
class IntSequence{ 
private: 
    int value; 
public: 
    IntSequence (int initialValue) 
        : value(initialValue) {} 
    int operator() () { 
        return value++; 
    } 
}; 
 
int main() 
{ 
    //freopen("out.txt", "w", stdout); 
    list<int> coll; 
    IntSequence seq(1); 
 
    generate_n<back_insert_iterator<list<int> >, 
                int, IntSequence&>(back_inserter(coll), 
                4, 
                seq); 
 
    PRINT_ELEMENTS(coll); 
 
    generate_n(back_inserter(coll), 
                4, 
                IntSequence(42)); 
    PRINT_ELEMENTS(coll); 
 
    generate_n(back_inserter(coll), 
                4, 
                seq); 
    PRINT_ELEMENTS(coll); 
 
    generate_n(back_inserter(coll), 
                4, 
                seq); 
    PRINT_ELEMENTS(coll); 
}

输出结果:
1 2 3 4
1 2 3 4 42 43 44 45
1 2 3 4 42 43 44 45 1 2 3 4
1 2 3 4 42 43 44 45 1 2 3 4 1 2 3 4

  • 6.(P305)

预定义的仿函数
要使用这些仿函数,必须包含头文件

1
#include <functional>

functor