字符串类String8

最新推荐文章于 2024-09-19 21:46:46 发布
原创 最新推荐文章于 2024-09-19 21:46:46 发布 · 2.6k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个仿Android String8工具类的设计与实现，包括构造函数、字符串操作方法及格式化输出等功能。通过示例展示了如何使用该类进行字符串拼接、格式化输出等常见操作。

仿Android 工具类String8写的

/*************************************************************************
    > File Name: string8.h
    > Author: hsz
    > Mail:
    > Created Time: 2021年04月11日 星期日 12时24分52秒
 ************************************************************************/

#ifndef __STRING8_H__
#define __STRING8_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <stdarg.h>
#include <stdint.h>
#include <ctype.h>

namespace Alias {

#define MAXSIZE (1024 * 8)

class String8 {
public:
                        String8();
                        String8(const String8& other);
                        String8(const char* other);
                        String8(const char* other, const size_t numChars);
                        String8(const std::string& other);

                        ~String8();

    const char*         c_str() const;
    std::string         toStdString() const;           // String8 -> std::string

    bool                isEmpty() const;
    size_t              length() const;
    void                clear();

    int                 append(const String8& other);
    int                 append(const char* other);
    int                 append(const char* other, size_t numChars);
	// this只能用于非静态成员函数，所以第一个参数就是fmt
    static String8      format(const char* fmt, ...) __attribute__((format(printf, 1, 2)));
    // 类成员函数第一个参数是隐藏的this指针   
    int                 appendFormat(const char* fmt, ...) __attribute__((format (printf, 2, 3)));  

    String8&            operator=(const String8& other);
    String8&            operator=(const char* other);

    String8&            operator+=(const String8& other);
    String8             operator+(const String8& other) const;

    String8&            operator+=(const char* other);
    String8             operator+(const char* other) const;

    int                 compare(const String8& other) const;
    int                 compare(const char* other) const;
    // if == return 0;
    int                 StrCaseCmp(const String8& other) const;
    int                 StrCaseCmp(const char* other) const;

    bool                operator<(const String8& other) const;
    bool                operator<=(const String8& other) const;
    bool                operator==(const String8& other) const;
    bool                operator!=(const String8& other) const;
    bool                operator>=(const String8& other) const;
    bool                operator>(const String8& other) const;

    bool                operator<(const char* other) const;
    bool                operator<=(const char* other) const;
    bool                operator==(const char* other) const;
    bool                operator!=(const char* other) const;
    bool                operator>=(const char* other) const;
    bool                operator>(const char* other) const;

    // return the index of the first byte of other in this at or after
    // start, or -1 if not found
    size_t              find(const char* other, size_t start = 0) const;

    // return true if this string contains the specified substring
    bool                contains(const char* other) const;
    bool                removeAll(const char* other);

    void                toLower();
    void                toLower(size_t start, size_t numChars);
    void                toUpper();
    void                toUpper(size_t start, size_t numChars);

private:
    char*               getBuffer(size_t numChars = 0);
    void                release();
    static String8      formatV(const char* fmt, va_list args);
    int                 appendFormatV(const char* fmt, va_list args);
    void                setTo(const String8& other);
    int                 setTo(const char* other);
    int                 setTo(const char* other, size_t numChars);

private:
    char *mString = nullptr;
};

} // namespace Alias
#endif // __STRING8_H__

/*************************************************************************
    > File Name: string8.cpp
    > Author: hsz
    > Mail:
    > Created Time: 2021年04月11日 星期日 12时25分02秒
 ************************************************************************/
/*************************************************************************
    > File Name: string8.cpp
    > Author: hsz
    > Mail:
    > Created Time: 2021年04月11日 星期日 12时25分02秒
 ************************************************************************/

#include "string8.h"

namespace Alias {

char *String8::getBuffer(size_t numChars)
{
    char *ret = nullptr;
    if (numChars <= 0) {
        ret = (char *)malloc(1);
        if (ret) {
            *ret = '\0';
        }
        return ret;
    } else if (numChars > 0) {
        ret = (char *)malloc(numChars + 1);
        if (ret) {
            memset(ret, 0, numChars + 1);
        }
        return ret;
    }
}

void String8::release()
{
    if (mString == nullptr) {
        return;
    }
    free(mString);
    mString = nullptr;
}

String8::String8()
{
    mString = getBuffer();
}

String8::String8(const String8& other)
{
    if (other.length() == 0) {
        mString = getBuffer();
        return;
    }
    mString = getBuffer(other.length());
    memcpy(mString, other.mString, other.length());
}

String8::String8(const char* other)
{
    if (other == nullptr) {
        mString = getBuffer();
        return;
    }
    size_t length = strlen(other);
    mString = getBuffer(length);
    memcpy(mString, other, length);
}

String8::String8(const char* other, const size_t numChars)
{
    if (other == nullptr) {
        mString = getBuffer();
        return;
    }
    size_t length = strlen(other);
    if (length > numChars) {
        length = numChars;
    }
    mString = getBuffer(length);
    memcpy(mString, other, length);
}

String8::String8(const std::string& other)
{
    size_t length = other.length();
    mString = getBuffer(length);
    memcpy(mString, other.c_str(), length);
}

String8::~String8()
{
    release();
}
size_t String8::find(const char* other, size_t start) const
{
    const char *tmp = strstr(mString + start, other);
    return tmp ? tmp - mString : -1;
}

const char* String8::c_str() const
{
    return mString;
}

std::string String8::toStdString() const
{
    return std::string(mString);
}

bool String8::isEmpty() const
{
    return length() == 0;
}

size_t String8::length() const
{
    return strlen(mString);
}

void String8::clear()
{
    memset(mString, 0, strlen(mString));
}

int String8::append(const String8& other)
{
    return append(other.mString, other.length());
}

int String8::append(const char* other)
{
    return append(other, strlen(other));
}

int String8::append(const char* other, size_t numChars)
{
    if (other == nullptr) {
        return -1;
    }
    size_t size = strlen(other);
    if (size > numChars) {
        size = numChars;
    }
    if (size == 0) {
        return 0;
    }

    size_t totalSize = size + length();
    char *buf = getBuffer(totalSize);
    if (buf) {
        memcpy(buf, mString, length());
        memcpy(buf + length(), other, size);
        this->release();
        mString = buf;
        return size;
    }
    return 0;
}

String8& String8::operator=(const String8& other)
{
    setTo(other);
    return *this;
}
String8& String8::operator=(const char* other)
{
    setTo(other);
    return *this;
}

String8& String8::operator+=(const String8& other)
{
    this->append(other);
    return *this;
}
String8 String8::operator+(const String8& other) const
{
    String8 tmp(*this);
    tmp += other;
    return tmp;
}
String8& String8::operator+=(const char* other)
{
    this->append(other);
    return *this;
}
String8  String8::operator+(const char* other) const
{
    String8 tmp(*this);
    tmp += other;
    return tmp;
}

int String8::compare(const String8& other) const
{
    return strcmp(mString, other.mString);
}

int String8::compare(const char* other) const
{
    return strcmp(mString, other);
}

int String8::StrCaseCmp(const String8& other) const
{
    return strcasecmp(mString, other.mString);
}

int String8::StrCaseCmp(const char* other) const
{
    return strcasecmp(mString, other);
}

bool String8::operator<(const String8& other) const
{
    return strcmp(mString, other.mString) < 0;
}
bool String8::operator<=(const String8& other) const
{
    return strcmp(mString, other.mString) <= 0;
}
bool String8::operator==(const String8& other) const
{
    return strcmp(mString, other.mString) == 0;
}
bool String8::operator!=(const String8& other) const
{
    return strcmp(mString, other.mString) != 0;
}
bool String8::operator>=(const String8& other) const
{
    return strcmp(mString, other.mString) >= 0;
}
bool String8::operator>(const String8& other) const
{
    return strcmp(mString, other.mString) > 0;
}

bool String8::operator<(const char* other) const
{
    return strcmp(mString, other) < 0;
}
bool String8::operator<=(const char* other) const
{
    return strcmp(mString, other) <= 0;
}
bool String8::operator==(const char* other) const
{
    return strcmp(mString, other) == 0;
}
bool String8::operator!=(const char* other) const
{
    return strcmp(mString, other) != 0;
}
bool String8::operator>=(const char* other) const
{
    return strcmp(mString, other) >= 0;
}
bool String8::operator>(const char* other) const
{
    return strcmp(mString, other) > 0;
}

void String8::setTo(const String8& other)
{
    setTo(other.mString, other.length());
}

int String8::setTo(const char* other)
{
    return setTo(other, strlen(other));
}

int String8::setTo(const char* other, size_t numChars)
{
    if (other == nullptr) {
        return -1;
    }
    numChars = numChars > strlen(other) ? strlen(other) : numChars;

    if (strlen(mString) >= numChars) {
        memset(mString, 0, strlen(mString));
        memcpy(mString, other, numChars);
    } else { // if (strlen(mString) < other.length()) 
        release();
        mString = getBuffer(numChars);
        memcpy(mString, other, numChars);
    }
}

bool String8::contains(const char* other) const
{
    return nullptr != strstr(mString, other);
}

bool String8::removeAll(const char* other)
{
    size_t start = 0;
    if (other && ((start = find(other)) >= 0)) {
        size_t end = strlen(other) + start;
        if (end >= length()) {
            mString[start] = '\0';
            return true;
        } else {
            size_t bufferSize = length() - (end - start);
            char *newString = getBuffer(bufferSize);
            if (newString == nullptr) {
                return false;
            }
            memcpy(newString, mString, start);
            memcpy(newString + start, mString + end, length() - end);
            free(mString);
            mString = newString;
            return true;
        }
    }
    return false;
}

void String8::toLower()
{
    toLower(0, length());
}

void String8::toLower(size_t start, size_t numChars)
{
    size_t size = length();
    if (size > start) {
        for (size_t i = start; i < numChars && i < size; ++i) { // i < size -> anti overflow
            mString[i] = static_cast<char>(tolower(mString[i]));
        }
    }
}

void String8::toUpper()
{
    toUpper(0, length());
}

void String8::toUpper(size_t start, size_t numChars)
{
    size_t size = length();
    if (size > start) {
        for (size_t i = start; i < numChars && i < size; ++i) { // i < size -> anti overflow
            mString[i] = static_cast<char>(toupper(mString[i]));
        }
    }
}

String8 String8::format(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);

    String8 result(formatV(fmt, args));

    va_end(args);
    return result;
}

String8 String8::formatV(const char* fmt, va_list args)
{
    String8 result;
    result.appendFormatV(fmt, args);
    return result;
}

int String8::appendFormat(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);

    int numChars = appendFormatV(fmt, args);

    va_end(args);
    return numChars;
}

int String8::appendFormatV(const char* fmt, va_list args)
{
    int n;
    va_list tmp_args;
    va_copy(tmp_args, args);
    n = vsnprintf(nullptr, 0, fmt, tmp_args);
    va_end(tmp_args);

    if (n < 0) {
        return n;
    }

    if (n > 0) {
        size_t oldLength = length();
        if ((size_t)n > MAXSIZE - 1 ||
            oldLength > MAXSIZE - (size_t)n - 1) {
            return -1;
        }

        char *buf = (char *)malloc(oldLength + n);
        if (buf == nullptr) {
            return -1;
        }
        memcpy(buf, mString, oldLength);
        release();
        vsnprintf(buf + oldLength, n + 1, fmt, args);
        mString = buf;
    }
    return n;
}
} // namespace Alias

测试（未测试全）

#include <iostream>
#include <stdio.h>
#include "string8.h"

int main()
{
    Alias::String8 str1;
    str1 = "123456789";
    str1.append("abcde", 3);
    std::cout << str1.c_str() << "\n";
    str1.appendFormat(" %p", str1.c_str());
    std::cout << "ptr = " << str1.c_str() << "\n";

    str1.clear();
    str1.appendFormat("[%d.%d.%d.%d]", 192, 168, 124, 7);
    std::cout << str1.c_str() << "\n";

    Alias::String8 str2 = str1;
    str2.appendFormat(" %p", str2.c_str());
    std::cout << "str2: "<< str2.c_str() << "\n";
    std::cout << str2.find("168.124.7") << "\n";
    std::cout << str2.contains("168.124.7") << "\n";
    std::cout << str2.compare(str1) << "\n";
    str2 = "ABcdEF";
    str2.toLower();
    std::cout << "toLower str2: "<< str2.c_str() << "\n";

    Alias::String8 str3(str1);
    std::cout << "str3: "<< str3.c_str() << "\n";
    std::cout << (str3 == str2) << "\n";
    str3 = "AbcdEF";
    std::cout << str3.StrCaseCmp(str2) << "\n";
    str3.toLower();
    std::cout << "toLower str3: "<< str3.c_str() << "\n";
    std::cout << "str3 == str2 -> " << (str3 == str2) << "\n";

    str3.removeAll("abcdef");
    str3 += str2;
    std::cout << "str3: "<< str3.c_str() << "\n";
    Alias::String8 str4 = str1 + str2 + str3;
    std::cout << str4.toStdString() << std::endl;

	Alias::String8 str5 = Alias::String8::format("%s", str4.c_str());
    std::cout << str5.toStdString() << std::endl;
    return 0;
}

运行结果

学习-Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
我写写哈的博客
09-26 2875
** 本关任务：使用 new 创建两个字符串（获取键盘输入的两个字符串，中间用空格分隔），并分别通过 equals 和 == 判断字符串是否相等。 ** 相关知识：为了完成本关任务，你需要掌握： 1.什么是字符串 2.字符串变量的声明 3.创建字符串的三种方式 4.equals 和 == 答案 什么是字符串 我们已经知道，数字、字母、汉字、符号等等都是字符，如 9、A、a、国、& 等。 那么，什么是字符串呢？ j 是一个字符，a、v、a 也是字符，现在我将这些字符连接起来，java 就是一个由 4
Educoder-学习-Java字符串之String类并置运算之字符串拼接
qq_39123467的博客
11-28 2229
掌握知识点 concat方法的使用 字符串灵活加减 通关代码 import java.util.Scanner; public class StrTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String fname = sc.next(); String lname = sc.next();
Android String8.h
w6028819321的专栏
07-07 8180
/frameworks/native/include/utils/String8.h
C++ string(八)
爱技术....爱生活！
08-31 702
#include const int SIZE = 5; using namespace std; void stringTest(); int main(int argc, const char * argv[]) { stringTest(); return 0; } void stringTest() {
java常用方法(String)8
lqxabcde的专栏
02-12 500
/** Removes all spaces from a string */ public static String removeSpaces(String str) { StringBuffer newString = new StringBuffer(); for (int i = 0; i < str.length(); i++) { ...
Java笔记(8)：String
tt19981212的博客
02-27 210
　　String属于引用类型，关于String的简单方法有：length()、charAt(index)、concat(s1)、toUpperCase()、toLowerCase()、trim()，由于这些方法只能从一个特定的字符串来调用，故也称为实例方法。String s3=s1.concat(s2);//连接两个字符串此语句等价于：String s3=s1+s2;加号若连接字符串和其他类型的值...
java8中的String
Mooneal的博客
11-02 1568
ps: 这篇博客是乱写的，笔记的形式，后面有空再整理。1.加载：生成Class对象，不放在堆中，存放在方法区中的元空间。 2.准备：正式为类变量（static）,分配内存，并设置默认初始值（数据类型的0值，比如，int 为 0）； 3.至此，类加载结束。但初始化还是要看时机的。 实例化的时候 new 调用其中的静态字段或者静态方法。 反射调用的时候。 4.什么时候被动引用，不引发初始化呢？
C++实现一个自定义字符串类（string）
2301_77754590的博客
04-13 2857
本博客将详细介绍如何在C++中实现一个自定义的字符串类 string，这个类模仿了标准库中 std::string 的关键功能。这个过程将涵盖从声明到定义的每一步，重点介绍内存管理、操作符重载以及提供一些关键的实现细节。
详解C++ string字符串类
12-25
C++字符串string类 在C语言里,字符串是用字符数组来表示的,而对于应用层而言,会经常用到字符串,而继续使用字符数组,就使得效率非常低. 所以在C++标准库里,通过类string从新自定义了字符串。 头文件: #include ...
Educoder-学习-Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
qq_39123467的博客
11-27 2512
掌握知识点 equals == 方法的使用 创建字符串的三种方式 通关源码 import java.util.Scanner; public class StrTest { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String s = scanner.next(); String s1 = scanner
C++ string类(上）
最新发布
XBHJBH的博客
09-19 461
拷贝构造函数。
java基础(8)--深入理解Java.String
上善若水，厚德载物
04-18 840
本文转载自：http://www.cnblogs.com/ITtangtang/p/3976820.html 尊重原创在讲解String之前，我们先了解一下Java的内存结构。一、Java内存模型按照官方的说法：Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。JVM主要管理两种类型内存：堆和非堆，堆内存（Heap Memory）是在 Java 虚拟机启动时创建，非
c++ string的详细用法（8）erase()
尔灵尔亿的博客
12-22 2128
string a="123456789"; 1.删除所有字符 a.erase(); //结果为 a=""; 2.从字符串的某一个位置开始删除 a.erase(n) //从字符串的第n个字符开始删除 a.erase(3); //结果为 a="123"; a.erase(5); //结果为 a="12345"; a.erase(0); //等同于a.erase() a=""; 3.从字符串的某一...
C++入门篇(8)之string使用
m0_51723227的博客
10-29 1152
文章目录前言basic_string模板介绍string的对象构造(初始化)string()string (const char* s)string(const string& s)string(size_t n,char c)string的容量操作size()和capacity()empty()和clear();resize()reserve()string的访问和遍历操作[]形式访问迭代器访问const迭代器和reverse迭代器范围遍历string的查找和修改push_back()append
C++ String16/String8与const char*及char*与vector相互转换(五十一)
Android系统攻城狮
05-16 8548
1.String16转const char* String16 name16 = String16("Hello World"); String8 name8 = String8(name16); const char *buffer = name8.string(); 验证： printf("buffer = %s\n",buffer); 注意： String16.string()其实是c...
String常用类型
weixin_42630877的博客
07-08 1481
（1） int compareTo(String other)         按照字典顺序，如果字符串位于other之间，返回一个负数；如果字符串位于other之后。返回一个正数：如果两个字符串相等，返回0.System.out.println("asasda".compareTo("sdsds"));//-18...
CPP-基础：String类
dixiongbi7761的博客
09-02 236
已知类String的原型为： class String { public: 　　String(const char *str = NULL); // 普通构造函数 　　String(const String &other); // 拷贝构造函数 　　~ String(void); ...
android底层库libutils之string8,string16研究
热门推荐
armwind的专栏
07-24 2万+
在之前看android camera framework代码时，发现代码中大量使用了string8、string16类。由于之前学习的是C#，java等高级面向对象语言唯独没有认真研究过C++。所以对C++中的string比较陌生。虽然他们的用法都是一样的，但是这里还是想认真研究一下底层实现原理。
C++(8):构造string的特殊方法
Leo的博客
08-16 1229
构造一个string对象有很多种方式，比如常见的几种 string s1; s1 = "you are the best"; string s2 = "you are the best"; string s3("you are the best"); string s4 = s1; 以上几种都是比较常见的string对象初始化的方式，这里再介绍几种其他的构造方式。 1.string s(c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值