您的位置：程序门 -> vc/mfc -> 非技术类

靠～～mfc的容器难用死啦

[收藏此页] [打印本页]选择字色：背景色：字体：[大][中][小]

靠～～mfc的容器难用死啦[已结贴,结贴人:rickerliang]

发表于：2007-01-18 23:23:47 楼主

mfc的clist之类的，真别扭啊，简直就是反人类啊
我是stl的忠实拥护者，但在公司不能用stl，靠，只能用mfc的容器，我日tmd，mfc的容器我不能接受啊～～～救命～～！！

发表于：2007-01-18 23:30:251楼得分:5

友情帮顶！！！

发表于：2007-01-19 00:39:512楼得分:5

只能怪你公司的领导菜菜，通用移值性，性能好的stl不用，却要把自己梆在mfc上。

同情+可怜ing？

最后问一句，到底为什么不让用stl？？

发表于：2007-01-19 08:05:233楼得分:5

反人类。。。暴寒。。。-_-!...

发表于：2007-01-19 08:06:034楼得分:2

我都素自己写这些~

发表于：2007-01-19 09:18:025楼得分:5

~@_@~

发表于：2007-01-19 09:27:196楼得分:2

mfc的容器也没你说的那么差吧！

发表于：2007-01-19 09:47:497楼得分:2

lz对mfc的容器有偏见，虽然不如stl，可也不能如此bs。。

发表于：2007-01-19 11:10:558楼得分:2

mfc的还行吧，但我不常用

发表于：2007-01-19 11:50:059楼得分:2

mfc的容器就是多了调试支持和序列化而已，而且已经不会有功能上的更新了。建议新代码还是使用stl。

发表于：2007-01-19 17:36:2610楼得分:0

stl序列化是软肋-_-!!!

发表于：2007-01-19 17:40:3511楼得分:0

人家（stl的)是容器，你（mfc的)也是容器，你（mfc的容器)怎么就不能给一种爽的感觉给我啊~~~
stl在导出类中使用会有诸多限制,这又是一软肋阿
-_-!!~~~

发表于：2007-01-19 21:27:4112楼得分:2

反人类这个词用得好!

发表于：2007-01-19 21:41:4313楼得分:2

stl导出类？？`````。。上次用stl做类型库的时候好象还是上个世纪。。现在一直用atl做动态库。

发表于：2007-01-19 23:32:5814楼得分:0

atl的确是个好东西

发表于：2007-01-20 12:05:0415楼得分:2

公认的ms对stl的支持最烂，不用ms的stl也是有道理的。

发表于：2007-01-20 12:06:4516楼得分:0

不相信的话，可以去翻翻看vc带的stl，跟看天书一个样。

如果一定要用stl的话，就自己去找一套好用的。

发表于：2007-01-20 15:01:4217楼得分:0

不知道ls在说啥，是混分么？
hoho ^_^

发表于：2007-01-20 18:37:3318楼得分:2

stl的确不错,mfc好些类我是从来不用的,比如容器类和csocket类等,能直接用api就用api,能用stl就用stl,mfc只用作框架.

发表于：2007-01-20 19:01:2719楼得分:2

mfc的容器也不错，尤其是和自己的mfc类对象还是很和的来的

发表于：2007-01-20 19:46:2820楼得分:2

stl号称30年来最好的库.

发表于：2007-01-21 04:52:0321楼得分:2

vc自带的stl不能用于正轨项目。可能会死人吧。

发表于：2007-01-21 08:28:5322楼得分:1

vs2005的stl还可以, 不知楼上几位说ms stl烂的是哪个版本的stl？具体表现在哪些地方？

发表于：2007-01-21 10:23:4623楼得分:2

mfc很久没用了，，大多数用atl，偶尔stl

发表于：2007-01-22 23:00:4224楼得分:0

其实mfc容器最令人恶心的使那个position和getnext、getat之类的东西，别扭的很
跟stl的iterator相比简直就是瞑王星跟太阳的区别

stl烂的是哪个版本的stl？
vc7.1之前的都很烂

发表于：2007-01-23 00:08:5325楼得分:2

哈哈

发表于：2007-01-23 11:32:3226楼得分:1

vc 的 stl 烂在哪里？摘抄一段下来以供欣赏，vc2003的 map

template <class _kty,
class _ty,
class _pr,
class _alloc> inline
void swap（map <_kty, _ty, _pr, _alloc> & _left,
map <_kty, _ty, _pr, _alloc> & _right)
{ // swap _left and _right maps
_left.swap（_right);
}

// template class multimap
template <class _kty,
class _ty,
class _pr = less <_kty> ,
class _alloc = allocator <pair <const _kty, _ty> > >
class multimap
: public _tree <_tmap_traits <_kty, _ty, _pr, _alloc, true> >
{ // ordered red-black tree of {key, mapped} values, non-unique keys
public:
typedef multimap <_kty, _ty, _pr, _alloc> _myt;
typedef _tree <_tmap_traits <_kty, _ty, _pr, _alloc, true> > _mybase;
typedef _kty key_type;
typedef _ty mapped_type;
typedef _ty referent_type; // retained
typedef _pr key_compare;
typedef typename _mybase::value_compare value_compare;
typedef typename _mybase::allocator_type allocator_type;
typedef typename _mybase::size_type size_type;
typedef typename _mybase::difference_type difference_type;
typedef typename _mybase::pointer pointer;
typedef typename _mybase::const_pointer const_pointer;
typedef typename _mybase::reference reference;
typedef typename _mybase::const_reference const_reference;
typedef typename _mybase::iterator iterator;
typedef typename _mybase::const_iterator const_iterator;
typedef typename _mybase::reverse_iterator reverse_iterator;
typedef typename _mybase::const_reverse_iterator
const_reverse_iterator;
typedef typename _mybase::value_type value_type;

multimap（)
: _mybase（key_compare（), allocator_type（))
{ // construct empty map from defaults
}

explicit multimap（const key_compare& _pred)
: _mybase（_pred, allocator_type（))
{ // construct empty map from comparator
}
multimap（const key_compare& _pred, const allocator_type& _al)
: _mybase（_pred, _al)
{ // construct empty map from comparator and allocator
}

template <class _iter>
multimap（_iter _first, _iter _last)
: _mybase（key_compare（), allocator_type（))
{ // construct map from [_first, _last), defaults
for （; _first != _last; ++_first)
insert（*_first);
}

template <class _iter>
multimap（_iter _first, _iter _last,
const key_compare& _pred)
: _mybase（_pred, allocator_type（))
{ // construct map from [_first, _last), comparator
for （; _first != _last; ++_first)
insert（*_first);
}

template <class _iter>
multimap（_iter _first, _iter _last,
const key_compare& _pred, const allocator_type& _al)
: _mybase（_pred, _al)
{ // construct map from [_first, _last), comparator, and allocator
for （; _first != _last; ++_first)
insert（*_first);
}

iterator insert（const value_type& _val)
{ // insert a {key, mapped} value
return （_mybase::insert（_val).first);
}

iterator insert（iterator _where, const value_type& _val)
{ // insert a {key, mapped} value, with hint
return （_mybase::insert（_where, _val));
}

template <class _iter>
void insert（_iter _first, _iter _last)
{ // insert [_first, _last), arbitrary iterators
for （; _first != _last; ++_first)
insert（*_first);
}
};

发表于：2007-01-24 12:09:3227楼得分:0

hoho 这是p.j. plauger的风格

发表于：2007-01-24 12:26:1828楼得分:0

hoho 这是p.j. plauger的风格
==========================

不是的~他们是故意这么弄的~

发表于：2007-01-25 12:11:0629楼得分:0

故意这么弄不就是风格么，hoho

下一篇：项目外包,会做网站和程序的来
上一篇：今天郁闷了，让大家和我一起分享一下

其他资讯