字符串匹配之BM算法

最近，涉及到android下的c++开发，但是麻烦在于，在android平台下编译的话，如果使用了标准库中的iostream, fstream等，会使得编译出来的二进制代码体积过度膨胀，

所以需要去除iostream等标准库的使用，当然， STL中的<string>模板也会使得代码体积增大， 是由于string间接包含了其他标准库文件；

同时，std::string采用模板技术，所以效率也不高，也会导致代码膨胀，处于各方面需要考虑，实现了一个简单的KyString类，作为内部使用：

当然，还有许多不足，请高人指教：

字符串KyString类实现的主要难度在于find以及rfind,如下为其核心字符串匹配算法，请参考代码实现：

BM算法正向查找字符串代码如下：

inline int index_BM(const char *S, const char *T, int pos = 0)  
{  
int i;  
int j;  


i = pos;  
j = 0;   


while ( (i < strlen(S)) && (j < strlen(T)) )  
{  
if (S[i] == T[j])  
{  
i++;  
j++;  
}  
else  
{  
i = i - j + 1;   
j = 0;  
}  
}  


if (strlen(T) == j)  
{  
return i - strlen(T);  
}  
else  
{  
return -1;  
}  
}

BM算法反向查找字符串代码如下：

inline int index_BMR(const char *S, const char *T, int pos = 0)  
{  
int i;  
int j;  


i = strlen(S);  
j = strlen(T);   


int len = strlen(T);


while ( (i > 0) && (j > 0) )  
{  


if (S[i - 1] == T[j - 1])  
{  
i--;  
j--;  
}  
else  
{  
i = i + (len - j) - 1;   
j = len;  
}  
}  


if (j == 0)  
{  
return i;  
}  
else  
{  
return -1;  
}  
}  

// KyStirng.h

#ifndef KYSTRING_H_
#define KYSTRING_H_


class KyString
{
friend KyString operator+(const KyString &lhs, const KyString &rhs);
public:
KyString();
KyString(const KyString &str);
KyString(const char *str);
~KyString();
KyString& operator=(const KyString &str);
public:
// 判断是否为空
bool empty() const;
// 获取字符串的大小
int size() const;
// 获取字符串的长度
int length() const;
//


const char* c_str();
//
void append(const char *str);
//
bool operator==(const KyString &str);
//
KyString& operator+=(const KyString &str);
//
int rfind(const char *sub) const;
//
int find(const char *sub) const;
//
KyString sub_str(int start, int end);
//
char& operator[](int idex);
//
const char& operator[](int idx) const;
private:
char *buffer;
};




#endif /* KYSTRING_H_ */

// KyString.cpp

#include <stdio.h>
#include <string.h>
#include "KyString.h"






KyString::KyString()
{
buffer = NULL;
}


KyString::KyString(const KyString &str)
{
if(str.buffer == NULL)
{
buffer = NULL;
}
else
{
buffer = new char[strlen(str.buffer) + 1];
strcpy(buffer, str.buffer);
}
}


KyString::KyString(const char *str)
{
if(str == NULL)
{
buffer = NULL;
}
else
{
buffer = new char[strlen(str) + 1];
strcpy(buffer, str);
}
}


KyString& KyString::operator=(const KyString &str)
{
if(this == &str)
{
return *this;
}
else
{
if(str.buffer == NULL)
{
buffer = NULL;
return *this;
}
else
{
if(buffer != NULL)
{
delete []buffer;
buffer = NULL;
}
buffer = new char[strlen(str.buffer) + 1];
strcpy(buffer, str.buffer);
}
}
}


KyString::~KyString()
{
if(buffer != NULL)
{
delete []buffer;
buffer = NULL;
}
}
// 判断是否为空
bool KyString::empty() const
{
if(buffer != NULL && strlen(buffer) > 0)
{
return true;
}
else
{
return false;
}


}


// 获取字符串的大小
int KyString::size() const
{
int size = strlen(buffer) + 1;
return size;
}


// 获取字符串的长度
int KyString::length() const
{
int len = strlen(buffer);
return len;
}


//
const char* KyString::c_str()
{
return buffer;
}


//
void KyString::append(const char *str)
{
if(str != NULL)
{
if(buffer != NULL)
{
int len_left = strlen(buffer);
int len_right = strlen(str);
char *tmp_buffer = new char[len_left + len_right + 1];
strcpy(tmp_buffer, buffer);
strcat(tmp_buffer, str);
delete []buffer;
buffer = NULL;
buffer = tmp_buffer;
}
else
{
int len = strlen(str);
buffer = new char[len + 1];
strcpy(buffer, str);
}
}
}


//
bool KyString::operator==(const KyString &str)
{
if(buffer == NULL || str.buffer == NULL)
{
return false;
}
else
{
if(!strcmp(buffer, str.buffer))
{
return true;
}
else
{
return false;
}
}




}




//
KyString& KyString::operator+=(const KyString &str)
{
if(this == &str)
{
return *this;
}


KyString tm;
tm.buffer = NULL;


if(str.buffer == NULL)
{
return *this;
}


if(buffer != NULL)
{
int len_left = strlen(buffer);
int len_right = strlen(str.buffer);
char *tmp_buffer = new char[len_left + len_right + 1];
strcpy(tmp_buffer, buffer);
strcat(tmp_buffer, str.buffer);
delete []buffer;
buffer = NULL;
buffer = tmp_buffer;
}
else
{
int len = strlen(str.buffer);
buffer = new char[len + 1];
strcpy(buffer, str.buffer);
}


}


KyString operator+(const KyString &lhs, const KyString &rhs)
{
KyString tmp;


tmp.append(lhs.buffer);
tmp.append(rhs.buffer);
return tmp;
}


inline int index_BMR(const char *S, const char *T, int pos = 0)  
{  
int i;  
int j;  


i = strlen(S);  
j = strlen(T);   


int len = strlen(T);


while ( (i > 0) && (j > 0) )  
{  


if (S[i - 1] == T[j - 1])  
{  
i--;  
j--;  
}  
else  
{  
i = i + (len - j) - 1;   
j = len;  
}  
}  


if (j == 0)  
{  
return i;  
}  
else  
{  
return -1;  
}  
}  


inline int index_BM(const char *S, const char *T, int pos = 0)  
{  
int i;  
int j;  


i = pos;  
j = 0;   


while ( (i < strlen(S)) && (j < strlen(T)) )  
{  
if (S[i] == T[j])  
{  
i++;  
j++;  
}  
else  
{  
i = i - j + 1;   
j = 0;  
}  
}  


if (strlen(T) == j)  
{  
return i - strlen(T);  
}  
else  
{  
return -1;  
}  
}
//
int KyString::rfind(const char *sub) const
{
if(sub == NULL)
{
return -1;
}
else
{
if(buffer == NULL)
{
return -1;
}
else
{
return index_BMR(buffer, sub);
}
}
}
//
int KyString::find(const char *sub) const
{
if(sub == NULL)
{
return -1;
}
else
{
if(buffer == NULL)
{
return -1;
}
else
{
return index_BM(buffer, sub);
}
}
}
//
KyString KyString::sub_str(int start, int end)
{
if(buffer == NULL)
{
return KyString("");
}


if(start < 0 || end <= 0 || end <= start)
{
return KyString("");
}
int len = end - start;
char *new_buffer = new char[len + 1];
memset(new_buffer, 0, len + 1);
memcpy(new_buffer, buffer + start, len);
KyString tmp(new_buffer);
delete []new_buffer;
new_buffer = NULL;
return new_buffer;
}


//
char& KyString::operator[](int idx)
{
if(buffer != NULL && idx >= 0 && idx < strlen(buffer))
{
return buffer[idx];
}
}
//
const char& KyString::operator[](int idx) const
{
if(buffer != NULL && idx >= 0 && idx < strlen(buffer))
{
return buffer[idx];
}
}