简单的ios控制台输入输出库

部分改动代码：
#ifndef __BASICCOMM_HEADER__
#define __BASICCOMM_HEADER__
#include "intype.h"
#ifndef INT32_MAX
#define INT32_MAX 0x7FFFFFFF
#endif
//预留增加空间大小
#define RSIZE 10
//格式化参数设置
template<typename T>
struct _fargs
{
int prec;
int width;
int llong;
T fill;
};
namespace diy
{
// 无符号数全位转16进制字符串，默认输出大写
template<typename Array, typename T>
void tohex(Array *s, T val, bool lower=false)
{
Array hex_tab1[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46
}; //16进制大写表
Array hex_tab2[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66
}; //16进制小写表
Array *hex_tab = lower ? hex_tab2 : hex_tab1;
for(int i = (sizeof(T) << 3) -4; i >=0; i-=4){
*s++ = hex_tab[(val>>i)& 0xf];
}
*s=0;
}
// swap交换函数
template<typename T>
void swap(T& left, T& right)
{
if(&left != &right){
T tmp = left;
left = right;
right = tmp;
}
}
// 反转数组函数
template<typename T>
void invert(T *beg, T *end)
{
for (; beg < end; ++beg, --end){
T t = *beg;
*beg = *end;
*end = t;
}
}
// 简单的取字符串长度函数
template<typename T>
size_t strlen(const T* s)
{
if(s==0) throw "string ptr is null";
size_t len;
for(len = 0; s[len]; ++len);
return len;
}
// 简单的字符串拷贝函数
template<typename T>
void copy(T *dst, const T *src, size_t len)
{
for(;*src && len > 0; --len){
*dst++ = *src++;
}
*dst = 0;
}
// 简单的字符串比较函数
template<typename T>
int strcmp(const T *a, const T *b)
{
for(; *a == *b; a++, b++)
if(*a == 0) return 0;
return (*a < *b) ? -1 : +1;
}
// 简单的字符串相等比较函数
template<typename T>
bool equal(const T *s, const T *dst, size_t dst_len)
{
for( ; dst_len > 0; ++s, ++dst, --dst_len){
if(*s != *dst) return false;
}
return true;
}
// 判断是否是令牌字符，分割函数用
template<typename T>
bool is_token(T ch, const T *tk)
{
while(*tk){
if(ch == *tk++) return true;
}
return false;
}
// 判断是否是数字字符
template<typename T>
bool is_digit(T ch)
{
return (ch >= 0x30 && ch <= 0x39);// 0-9
}
// 是否是小写字母
template<typename T>
bool is_lower(T ch)
{
return (ch >= 0x61 && ch <= 0x7a );
}
// 是否是大写字母
template<typename T>
bool is_upper(T ch)
{
return (ch >= 0x41 && ch <= 0x5a );
}
// 无符号数10进制转换
template<typename Array, typename T>
size_t uitoa(Array *s, T val, bool sign = false)
{
Array *p = s;
do{
*p++ = (Array)(val % 10) + 0x30;//'0'
}while(val/=10);
if(sign) *p++ = 0x2d;//'-'
*p = 0;
invert(s, p-1); // 反序
return p-s;
}
// 无符号数2,8,16进制快速转换
template<typename Array, typename T>
size_t fast_uitoa(Array *s, T val, int base, bool sign=false, bool lower=false)
{
if((base & 1) == 0)//是2的n次方
{
Array hex_tab1[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46
}; //16进制大写表
Array hex_tab2[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66
}; //16进制小写表
Array *hex_tab = lower ? hex_tab2 : hex_tab1;
Array *p = s;
int c = 0, b = base;
switch(base){
case 2: c = 1; break;
case 8: c = 3; break;
case 16: c = 4; break;
default:
while(b>>=1) ++c; //计算是2的多少次方
}
do{
*p++ = hex_tab[val&(base-1)];
}while(val>>=c);
if (sign) *p++ = 0x2d;//'-'
*p = 0;
invert(s, p-1);
return p-s;
}
return 0;
}
union Int64{
struct _part{
unsigned int low;
int high;
}part;
int64_t val;
};
// 提取字符串中的正整数，只考虑了整数溢出，没有考虑负数，前导空格
// 出错返回0
template<typename T>
int stoi(const T *s, int &i)
{
Int64 n;
for(n.val = 0, i = 0; is_digit(*s); ++s, ++i){
n.val = (n.val << 3) + (n.val << 1) + *s - 0x30;
}
if(n.val > INT32_MAX || i > 10) n.val = 0;
return n.part.low;
}
// 简单的数组内存分配
template<typename T>
bool alloc(T **src, size_t len)
{
T *p;
try{
p = new T[len];
if(*src){
delete[] *src;
}
*src = p;
return true;
}
catch(...)
{
return false;
}
}
// 简单的数组重分配函数
template<typename T>
bool realloc(T **src, size_t src_size, size_t new_size)
{
T *p;
try{
p = new T[new_size+1];
if(*src){
size_t len = (src_size < new_size) ? src_size : new_size;
copy(p, *src, len);
delete[] *src;
}
*src = p;
return true;
}
catch(...)
{
return false;
}
}
}// end namespace
#endif

总结一下：造轮子还是一件有趣的事，完全手工代码，通过实现format函数，更进一步理解printf那些所谓的控制符的作用的意义。模版函数的应用，更是通过这个小项目，它的应用价值更进一步的自我体会，说白了就是函数的多态性，写一遍代码，可以倒处应用，相比于C语言的为了实现相同功能，普遍使用不同的函数名，比如ms的那一堆wprintf, printf, wsprintf, sprintf......strlen, wcslen等等，模版函数的另一个特点就是在编译期就会提醒错误的调用参数，第三个特点，无需要进行库的链结，模版函数在不调用的情况下，并不会产生相应的函数体代码，当然，这会相应增加编译的时间 。函数代码完全掌握在自己手中，可以随时进行改进，感觉的确爽，有些明白那些喜欢造轮子的大佬的心情了。

库编译时需要添加EXPORT_DLL宏，用于生成dll，
PS：dll导出库可以用于同系列不同版本的链结器，和静态库不同，不同版本互不兼容。
测试代码：
#include "console.h"
#include "string.h"
//一个有趣的现象，库可以在头添加成员变量，而链结时无须成员变量。
Console cout;
int main()
{
string s("hellovfp is here!");
short a = 3256;
cout.setColor(ios::yellow);
cout << s.length() << ":" << s.capacity() << "\n";
cout.puts(s);
cout.gotoxy(3,2);
cout << s << a << "\n";
//s.format("Power string of len:%u, capacity:%u", s.length(), s.capacity());//这个会增加5K
cout << s;
cout.resetColor();
return 0;
}

重新修改了查找代码，测试结果还是很令人满意，特别是右查找的速度，比std::string的速度快3倍左右。爽啊

同时也发现std::string中右查找的一个问题，当查找字串为空串时，rfind返回是字符串最后空字符串的位置，而并不是返回npos，个人觉得对空串进行查找，无意义，令人头疼的一个问题。另一个奇怪的事，查找C库函数，只有左查找子串strstr，并没有右查找函数，相比来说，C++ string的使用方便性还是考虑到了这一点。