String类的包装 ---- 类实现

最新推荐文章于 2022-08-09 17:18:46 发布
最新推荐文章于 2022-08-09 17:18:46 发布
阅读量2.5k 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leehong2005/article/details/8607617
版权

接上一篇《String类的包装 ---- 类声明》

这是SdkString类的方法实现，每个方法都经过我测试，应该没有问题。如果大家发现有写得效率不高或者BUG的地方，可以进行回贴指出。


// SdkString.cpp

#ifndef SAFE_DELETE_ARRAY
#define SAFE_DELETE_ARRAY(p)    { if ((p) != NULL) { delete [] (p); (p) = NULL; } }
#endif


#define DEFAULT_CAPACITY        20


SdkString::SdkString()
{
    m_maxCapacity   = DEFAULT_CAPACITY;
    m_pDataArray    = new wchar_t[m_maxCapacity];
    memset(m_pDataArray, 0, m_maxCapacity);
}
//
SdkString::SdkString(const wchar_t* lpsrcStr)
{
    if ( NULL == lpsrcStr )
    {
        m_maxCapacity   = DEFAULT_CAPACITY;
        m_pDataArray    = new wchar_t[m_maxCapacity];
        memset(m_pDataArray, 0, m_maxCapacity);
    }
    else
    {
        int length      = wcslen(lpsrcStr);
        m_maxCapacity   = sizeof(wchar_t) * (length + 1) + DEFAULT_CAPACITY;
        m_pDataArray    = new wchar_t[m_maxCapacity];
        memset(m_pDataArray, 0, m_maxCapacity);
        memcpy_s(m_pDataArray, m_maxCapacity, lpsrcStr, length * sizeof(wchar_t));
    }
}
//
SdkString::SdkString(const SdkString& srcStr)
{
    m_maxCapacity = srcStr.m_maxCapacity;
    m_pDataArray = new wchar_t[m_maxCapacity];
    memset(m_pDataArray, 0, m_maxCapacity);
    memcpy_s(m_pDataArray, m_maxCapacity, srcStr.m_pDataArray, srcStr.m_maxCapacity);
}
//
SdkString::~SdkString()
{
    m_maxCapacity = DEFAULT_CAPACITY;
    SAFE_DELETE_ARRAY(m_pDataArray);
}
//
SdkString& SdkString::operator =(const SdkString& srcStr)
{
    if ( this == &srcStr )
    {
        return *this;
    }
    m_maxCapacity = DEFAULT_CAPACITY;
    SAFE_DELETE_ARRAY(m_pDataArray);
    m_maxCapacity = srcStr.m_maxCapacity;
    m_pDataArray  = new wchar_t[m_maxCapacity];
    memset(m_pDataArray, 0, m_maxCapacity);
    memcpy_s(m_pDataArray, m_maxCapacity, srcStr.m_pDataArray, srcStr.m_maxCapacity);
    return *this;
}
//
SdkString& SdkString::operator =(const wchar_t* lpsrcStr)
{
    SAFE_DELETE_ARRAY(m_pDataArray);
    if ( NULL == lpsrcStr )
    {
        m_maxCapacity = DEFAULT_CAPACITY;
        m_pDataArray = new wchar_t[m_maxCapacity];
        memset(m_pDataArray, 0, m_maxCapacity);
    }
    else
    {
        int length = wcslen(lpsrcStr);
        m_maxCapacity = sizeof(wchar_t) * (length + 1) + DEFAULT_CAPACITY;
        m_pDataArray = new wchar_t[m_maxCapacity];
        memset(m_pDataArray, 0, m_maxCapacity);
        memcpy_s(m_pDataArray, m_maxCapacity, lpsrcStr, length * sizeof(wchar_t));
    }
    return *this;
}
//
SdkString& SdkString::Append(const wchar_t* lpsrcStr)
{
    if ( NULL == lpsrcStr )
    {
        return *this;
    }
    int length    = wcslen(lpsrcStr);
    int curlength = wcslen(m_pDataArray);
    int leftSpace = (m_maxCapacity - (curlength + 1) * sizeof(wchar_t));
    // If the left space can contain the new data
    if ( leftSpace >= (int)((length + 1) * sizeof(wchar_t)) )
    {
        memcpy_s(m_pDataArray + curlength, m_maxCapacity,
                 lpsrcStr, length * sizeof(wchar_t));
    }
    else
    {
        m_maxCapacity += (sizeof(wchar_t) * (length + 1) + DEFAULT_CAPACITY);
        wchar_t *pTempDataArr = new wchar_t[m_maxCapacity];
        memset(pTempDataArr, 0, m_maxCapacity);
        memcpy_s(pTempDataArr, m_maxCapacity, 
                 m_pDataArray, curlength * sizeof(wchar_t));
        memcpy_s(pTempDataArr + curlength, 
                 m_maxCapacity, lpsrcStr, length * sizeof(wchar_t));
        SAFE_DELETE_ARRAY(m_pDataArray);
        m_pDataArray = pTempDataArr;
    }
    return *this;
}
//
SdkString& SdkString::Format(const wchar_t* lpformat, ...)
{
    if ( (NULL == lpformat) || (0 == wcslen(lpformat)) )
    {
        return *this;
    }
    va_list args;
    va_start(args, lpformat);
    int length = _vscwprintf(lpformat, args) + 1;
    wchar_t *pBuffer = new wchar_t[length];
    memset(pBuffer, 0, length);
    _vswprintf_s_l(pBuffer, length, lpformat, NULL, args);
    va_end(args);
    *this = pBuffer;
    SAFE_DELETE_ARRAY(pBuffer);
    return *this;
}
//
SdkString& SdkString::MakeLower()
{
    _wcslwr_s(m_pDataArray, wcslen(m_pDataArray) * sizeof(wchar_t));
    return *this;
}
//
SdkString& SdkString::MakeUpper()
{
    _wcsupr_s(m_pDataArray, wcslen(m_pDataArray) * sizeof(wchar_t));
    return *this;
}
//
SdkString& SdkString::MakeReverse()
{
    int length = wcslen(m_pDataArray) - 1;
    wchar_t chTemp = 0;
    for (int i = 0; i < length; ++i, --length)
    {
        chTemp = m_pDataArray[i];
        m_pDataArray[i] = m_pDataArray[length];
        m_pDataArray[length] = chTemp;
    }
    return *this;
}
//
SdkString SdkString::SubString(int startIndex, int length)
{
    int curlen = wcslen(m_pDataArray);
    if ( (length < 0) || (startIndex + length > curlen) )
    {
        return SdkString();
    }
    length     = (length > curlen) ? curlen : length;
    startIndex = (startIndex < 0) ? 0 : startIndex;
    int capacity = sizeof(wchar_t) * (length + 1);
    wchar_t *pTempData = new wchar_t[capacity];
    memset(pTempData, 0, capacity);
    memcpy_s(pTempData, capacity, m_pDataArray + startIndex, length * sizeof(wchar_t));
    SdkString strRet(pTempData);
    SAFE_DELETE_ARRAY(pTempData);
    return strRet;
}
//
bool SdkString::IsEmpty() const
{
    return (0 == wcslen(m_pDataArray));
}
//
bool SdkString::IsContains(const wchar_t* lpstrValue, bool ignoreCase) const
{
    if ( (NULL == lpstrValue) || (0 == wcslen(lpstrValue)) )
    {
        return false;
    }
    int length = wcslen(m_pDataArray);
    int valuelen = wcslen(lpstrValue);
    if ( length < valuelen )
    {
        return false;
    }
    int j = 0;
    int offsetIndex = 0;
    // If ignore lower or upper case
    if ( ignoreCase )
    {
        while ( j < valuelen )
        {
            if ( (offsetIndex + valuelen) > length )
            {
                return false;
            }
            if ( *(m_pDataArray + offsetIndex + j) == *(lpstrValue + j) ||
                 (*(m_pDataArray + offsetIndex + j) - *(lpstrValue + j) == 0x20) ||
                 (*(lpstrValue + j) - *(m_pDataArray + offsetIndex + j) == 0x20) )
            {
                j++;
            }
            else
            {
                j = 0;
                offsetIndex++;
            }
        }
    }
    else
    {
        while ( j < valuelen )
        {
            if ( (offsetIndex + valuelen) > length )
            {
                return false;
            }
            if ( *(m_pDataArray + offsetIndex + j) == *(lpstrValue + j) )
            {
                j++;
            }
            else
            {
                j = 0;
                offsetIndex++;
            }
        }
    }
    return (j == valuelen);
}
//
bool SdkString::IsStartWith(wchar_t ch) const
{
    if ( wcslen(m_pDataArray) > 0 )
    {
        if ( ch == *(m_pDataArray + 0) )
        {
            return true;
        }
    }
    return false;
}
//
bool SdkString::IsStartWith(const wchar_t* lpsrcStr) const
{
    if ( NULL == lpsrcStr )
    {
        return false;
    }
    int length = wcslen(m_pDataArray);
    int srclen = wcslen(lpsrcStr);
    if ( (0 == srclen) || (srclen > length))
    {
        return false;
    }
    for (int i = 0; i < srclen; ++i)
    {
        if ( *(m_pDataArray + i) != *(lpsrcStr + i) )
        {
            return false;
        }
    }
    return true;
}
//
bool SdkString::IsEndWith(wchar_t ch) const
{
    int length = wcslen(m_pDataArray);
    if ( length > 0 )
    {
        if ( ch == *(m_pDataArray + length - 1) )
        {
            return true;
        }
    }
    return true;
}
//
bool SdkString::IsEndWith(const wchar_t* lpsrcStr) const
{
    if ( NULL == lpsrcStr )
    {
        return false;
    }
    int length = wcslen(m_pDataArray);
    int srclen = wcslen(lpsrcStr);
    if ( (0 == srclen) || (srclen > length))
    {
        return false;
    }
    for (int i = 0; i < srclen; ++i)
    {
        if ( *(m_pDataArray + length - srclen + i) != *(lpsrcStr + i) )
        {
            return false;
        }
    }
    return true;
}
//
bool SdkString::IsEqual(const wchar_t* lpsrcStr, bool ignoreCase) const
{
    if ( (NULL == lpsrcStr) )
    {
        return false;
    }
    int length = wcslen(m_pDataArray);
    int srclen = wcslen(lpsrcStr);
    if ( length != srclen )
    {
        return false;
    }
    if ( (0 == length) && (0 == srclen) )
    {
        return true;
    }
    if ( ignoreCase )
    {
        for (int i = 0; i < length, i < srclen; ++i)
        {
            if ( *(m_pDataArray + i) != *(lpsrcStr + i) &&
                 (*(m_pDataArray + i) - *(lpsrcStr + i) != 0x20) &&
                 (*(lpsrcStr + i) - *(m_pDataArray + i) != 0x20) )
            {
                return false;
            }
        }
    }
    else
    {
        for (int i = 0; i < length, i < srclen; ++i)
        {
            if ( *(m_pDataArray + i) != *(lpsrcStr + i) )
            {
                return false;
            }
        }
    }
    return true;
}
//
const wchar_t* SdkString::ToString() const
{
    return m_pDataArray;
}
//
size_t SdkString:: GetSize_r() const
{
    return wcslen(m_pDataArray);
}



leehong2005
关注
专栏目录
全网最全-谷粒商城项目-面试总结-简历优化
成功最快的秘诀: 抱团取暖 。
09-20 28万+
该系用采用SpringCloud架构，利用SpringBoot构建应用，利用Nacos作为服务的注册、配置中心，利用OpenFeign实现与其他模块进行交互，利用Sentinel实现熔断降级和错误处理，利用Gateway作为服务网关，利用RabbitMQ实现延迟队列，利用Redis作为缓存解决读多写少的场景，利用MySQL进行持久化，利用MyBatisPlus作为持久化框架。
2022-07-22 第八小组 常竞文 String类型和八大包装类
cjwtsl的博客
07-26 405
在Java中为了执行效率，在类加载时刻会在方法区中会声明并初始化一个长度为256的Integer静态常量数组，其中存储了范围在[-128,127]中的Integer对象，我们将这个Integer数组为称作整数型常量池。------->通过一个String类型的数据创建一个Integer对象。------->获取int类型的最小值。------->通过一个int类型数据创建一个Integer对象。------->获取int类型的最大值。------->将当前Integer类型转换成int类型。...
String_包装类
云端飞翔
07-09 1064
String类适用于描述字符串事物。 字符串操作方法： 1，获取：  1.1 字符串中的包含的字符数，也就是字符串的长度。   int length():获取长度。  1.2 根据位置获取位置上某个字符。   char charAt(int index):  1.3 根据字符获取该字符在字符串中位置。   int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。   int
String类，包装类，
q540694991的博客
09-30 1785
记录学习Java的问题和经验——3 1.String类(类的首字母大写）： 在 Java 中，字符串被作为 String 类型的对象处理。 String 类位于 java.lang 包中。默认情况下，该包被自动导入所有的程序。 String创建方法： public class HelloWorld { public static void main(String[] args)
包装类、String类
zhang666zhang的博客
11-08 1356
1. 包装类（位于java.lang中） ① 概念：对8种基本数据类型分别定义了对象类型，这些类称为基本数据类型包装类。     ② 基本数据-包装类：【重点】             基本数据类型          包装类                 byte               Byte short              Short int             
Day13包装类及String字符串
jkhm168的博客
08-04 230
Day13笔记 一、包装类 1、包装类介绍 含义：基本数据类型对应的类 出现原因： Java为纯面向对象语言(万物皆对象)，而8种基本数据类型不能创建对象，破坏了Java为纯面向对象 语言的特征，所以Java又给这8种基本数据类型分别匹配了对应的类，这种叫做包装里/封装类 继承关系： 基本数据类型 引用数据类型 byte Byte extends Number extends Object short Short extends Number extends Object i
Java-String类及包装类
简之恨寒的博客
08-09 1101
但是当需要和其他对象结合使用，如存入集合中，就需要将基础数据类型实例化为Java对象，为了面向对象的这一特性，基本数据类型中的每一个类型在java.lang包中都有一个包装类，即将每个基本类型都包装成了一个类。包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，而“= =”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“= =”比较时会先做自动拆箱处理。因为 String 对象是不可变的，所以可以共享。...
Java的String及其包装类总结
qq_36556651的博客
06-01 1402
Java为字符串维护了一个字符串常量池，在方法区中，方法区内存的是不会轻易改变的内容，而字符串一旦被赋值，便是不可改变的。这里对不可变性做个解释： Java字符串的不可变是指值不可改变，但是引用可以改变，比如当为字符串s赋值为abcd后，再赋值成abcedl，不是在原有的内存地址上进行修改，而是重新指向一个新的对象、地址。 围绕着字符串常量池面试时经常会有很多考点，比如： String s1...
Java常用类与基础API-String的构造器与常用方法
最新发布
02-15
// String 类内部实现 public String() { this.value = "".value; } ``` - `public String(String original)`： - 示例代码： ```java // 2. public String(String original) @Test public void test2()...
Java学习资料-包装类
06-14
- **转换**：可以使用包装类的构造函数实现基本类型到包装类的转换，反之则通过特定的方法（如intValue、doubleValue等）进行拆箱。 - **字符串转数值**：Integer类的parseInt方法和Float类的parseFloat方法可以将...
java6string源码-uli-wsgen:用于接口的“wsgen-wsdl”
06-04
java6string源码ULI-WSGEN 我们的目标是实现wsgen -wsdl的替代品，它能够从接口而不是具体实现创建 wsdl 文件。 目前，这项工作正在进行中。 现在有一个工作原型，但目前它非常丑陋。 对于我们使用的第三方产品，请...
String类、基本数据类型包装类
Dream-Just do it !
03-18 643
一、String 1、知识点  （1）、因为被final修饰，所以不能被继承  （2）、 字符串一旦被初始化就不可以被改变（是指字符串，而不是引用的指向）  （3）、String s1=””;和String s1=new Strin
string基本包装类型
黑夜来袭Z
02-19 849
String 类型的每个实例都有一个 length 属性，表示字符串中包含多个字符 var stringValue = "hello world"; alert(stringValue.length); //"11" 访问指定索引处的字符或字符编码：charAt()、charCodeAt() var stringValue = "hello world"; alert(stringValue.charAt(1)); //"e" 以数组的形式访问字符 var stringValue = "he
String类和包装类
L935290838的博客
07-19 194
Sring类和包装类
Java基础学习第七讲：Java中的String类、常用类及包装类
跟着老高学Java
01-06 902
Java中的String类、常用类及包装类
Java 包装类和String类
yangliye2020的博客
04-05 265
包装类   为8种基本数据类型各自提供一个类。即把基本数据类型转换成对应的对象形式。   JDK5之后：  Object o = 任何数据 ； 基本类型和包装类之间的转换   JDK5.0之后：编译器提供自动封箱功能，虚拟机则执行实际转换后的代码。 int i = 2; Integer a = Integer.valueOf(i); Integer a = 5; // Intege...
String类的包装 ---- 类声明
永远即等待的专栏
02-24 1072
这是我用C++语言实现的一个String类，类的声明如下： 目前还没有重载 + 操作符，有时间把这个也实现。   说明：CPP中实现有些用到库函数，我这里没有表出所引用的头文件。因此直接拷贝可能会导致编译错误。 // SdkString.h class SdkString { public:     // 构造函数     SdkString();
java基础String/包装类
y515274057的专栏
10-20 350
字符串(掌握) (1)字符串：很多个字符组成的一串数据。 (2)特点： 字符串一旦被赋值,就不可以被改变。它在常量池里面。 (3)面试题： String s = new String("abc"); 和String s = "abc";的区别？ 请写出下面的结果： String s1 = new String("hello"); String s2 = new String("hello"); s
DB-UNIFIER：统一数据库包装工具使用教程
"DB-UNIFIER是一个用于统一各种关系型数据库包装的工具，提供简便高效的接口，简化数据库操作，特别是分页查询和大对象处理。它由虞越开发，遵循GNU Lesser General Public License (LGPL)，源代码可在GitHub、CSDN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值