吞吞相报何时了…
不说闲话。
包括:
一系列好玩的可以替代printf的高效智能print函数
cov::genericType泛型，基础类型放心去用呗，不需要担心啥类型。类型什么的都不是事～
cov::handler智能指针，把资源交给我，我帮你打理。效率高，还不用担心内存泄露和那堆的内存错误。
cov::timer高精度计时器，精度高达纳秒，麻麻再也不用担心程序计时了
@DXKite @_柒月初七 @ljt12138 @九尾沧海忆 @1421126961
别再吞了！我没打广告！

持续更新！会加入更多好玩的东西，只要你想要！

吞吞相报没个完啊…度娘也是够了…

怎么用

围观
目测技术是追不上
lz
了。。。。。
不过我也不会封装。。。。。
管他呢，反正我准备鼓捣算法去
魅族

getch貌似有延迟

libkoll不服

楼主，我要一封装的链表......
我装的貌似内存溢出
成员函数：
inline void add(T newContent);
inline void add(T newContent, unsigned int index);
inline void star();
inline bool next();
inline bool end();
inline T & operator [] (unsigned int index);
inline T & last();
inline T & at(unsigned int index);
inline T & at();
inline bool remove(unsigned int index);
inline bool remove();
inline void clear();
inline int Sum();
inline int Index();

// @丿小夕ve
template < typename InType, typename T = cov::handler < InType > >class cov::list
{
protected:
class node
{
friend class list;
friend class iterator;
T data;
node *front = 0;
node *behind = 0;
};
public:
class iterator
{
friend class list;
protected:
node * me;
public:
iterator():me(0)
{
}
iterator(node * ptr):me(ptr)
{
}
iterator(const iterator &) = default;
operator bool() const
{
return me;
}
T & operator*() const
{
if (me)
return me->data;
}
T *operator->() const
{
if (me)
return &me->data;
}
iterator & operator++()
{
me = me->behind;
return *this;
}
iterator & operator--()
{
me = me->front;
return *this;
}
bool operator==(const iterator & obj)
{
return me == obj.me;
}
bool operator!=(const iterator & obj)
{
return me != obj.me;
}
};
protected:
node * m_head;
node *m_end;
long m_size = 0;
public:
list():m_head(0), m_end(0)
{
}
list(const list & in);
~list();
void clear();
const list & operator=(const list & in);
void push_front(const T & obj);
void push_back(const T & obj);
void pop_front();
void pop_back();
void insert(iterator it, const T & obj);
void erase(iterator & it);
void remove(const T & obj);
long size() const
{
return m_size;
}
iterator head()
{
return list < InType, T >::iterator(m_head);
}
iterator tail()
{
return list < InType, T >::iterator(m_end);
}
};

文件复制那个应该可以改进一下，理论缓存对缓存的copy理论会快一点，当然也许我是错误的

template < typename T > class Chain {
protected:
unsigned int index = 0, sum = 0;
/*记录下标和总数*/
struct Unit {
T content;
Unit *next;
} *head = NULL, *tail = NULL, *position = head;
/*每一个节点(先叫节点吧)*/
public:
Chain();
~Chain();
inline void add(T newContent);
/*末尾添加*/
inline void add(T newContent, unsigned int index);
/*添加到第index个*/
inline void star();/*position指向第一个节点*/
inline bool next();/*position移向下一个节点*/
inline bool end();;/*判断position到达尾节点*/
inline T & at();/*获取当前position节点内容*/
inline int Index();/*返回当前position下标*/
inline bool remove();/*删除当前position节点*/
inline T & operator [] (unsigned int index);/*获第index个的内容*/
inline T & last();/*获最后一个的内容*/
inline T & at(unsigned int index);/*获第index个的内容*/
inline bool remove(unsigned int index);/*删除第index个的节点*/
inline void clear();/*删除全部*/
inline int Sum();/*返回总数*/
};
poition,没太大关系；
是固定储当前位置，每次访问直接取，用next()才后移，
因为很多情况是不用下标的，才设了这个
效率约是用[index]的2倍
at(index)和[index]是差不多的，

最近在研究可以用来装X的 C++ Name Mangling。
extern "C++" void *foo(void *);
extern "C" void *_Z3fooPv(void *);
上面的两个声明在 GNU 环境下指向的是同一个函数。

Boom!重磅炸弹
@Wiseluster @九尾沧海忆 @ljt12138 @_柒月初七 @DXKite
已经实现支持任意类型的switch

这回我要无耻地申精了
@傻傻_痴痴 @洋蛋炒饭

二进制文件吗，我还以为是源码