简介： CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！

优质专栏：Audio工程师进阶系列【原创干货持续更新中……】🚀
优质专栏：多媒体系统工程师系列【原创干货持续更新中……】🚀

人生格言： 人生从来没有捷径，只有行动才是治疗恐惧和懒惰的唯一良药.

更多原创,欢迎关注：Android系统攻城狮

1.前言

本篇目的：Android14之模板类StaticString16解析

2.StaticString16模板类介绍

• Android 系统是一个基于 Linux 内核的开源操作系统，广泛应用于各种移动设备。在 Android 开发过程中，为了提高开发效率和可维护性，系统提供了一系列模板类，以简化特定类型的编程任务。StaticString16 是 Android 系统中一个用于处理 16 位字符串常量的模板类。
• StaticString16 模板类的作用类似于 C++ 中的字符串常量，但它仅支持 16 位字符。在 Android 开发中，我们经常需要处理多种语言的字符串，而不同语言的字符集可能不同。StaticString16 正是为了解决这个问题而设计的。使用 StaticString16 可以让开发者编写更加通用和高效的代码，因为它是专门针对 16 位字符设计的。
• StaticString16 模板类具有以下特点：

1. 高效性：由于 StaticString16 专门针对 16 位字符设计，因此它的存储和处理效率更高。
2. 可移植性：StaticString16 模板类可以处理多种语言的字符串，使得开发者编写的代码具有更好的可移植性。
3. 安全性：StaticString16 模板类是 Android 系统的一部分，因此它的安全性和稳定性得到了保证。
4. 易用性：StaticString16 模板类提供了简单的接口，使得开发者可以轻松地使用它来处理 16 位字符串常量。

• 在 Android 开发过程中，使用 StaticString16 模板类可以带来很多好处。例如，在定义字符串常量时，我们可以使用 StaticString16 类型来指定字符串的长度为 16 位，这样可以确保字符串在不同的设备上都能正确显示。此外，使用 StaticString16 还可以避免在字符串常量中出现不必要的空格和换行符等问题。
• 总之，StaticString16 是 Android 系统中一个非常有用的模板类。它专门用于处理 16 位字符串常量，具有高效、可移植、安全和易用等特点。在 Android 开发过程中，合理地使用 StaticString16 模板类可以提高开发效率，降低软件维护成本。

3.StaticString16模板类分析

<1>.StaticString16模板类实现

template <size_t N>
class StaticString16 : public String16 {
public:
    constexpr StaticString16(const char16_t (&s)[N]) : String16(mData), mData(makeStaticData(s)) {}

    constexpr StaticString16(const StaticString16<N>& other): String16(mData), mData(other.mData) {}

    constexpr StaticString16(const StaticString16<N>&&) = delete;
    static void* operator new(std::size_t) = delete;

private:
    const StaticData<N> mData;
};

StaticString16模板类继承自String16类。
下面看下String16构造函数。

<2>.String16定义

class String16
{
public:
                                String16();
                                String16(const String16& o);
                                String16(String16&& o) noexcept;
                                String16(const String16& o,
                                         size_t len,
                                         size_t begin=0);
    explicit                    String16(const char16_t* o);
    explicit                    String16(const char16_t* o, size_t len);
    explicit                    String16(const String8& o);
    explicit                    String16(const char* o);
    explicit                    String16(const char* o, size_t len);

                                ~String16();

    inline  const char16_t*     string() const;

private:
    static inline std::string   std_string(const String16& str);
public:
            size_t              size() const;
            void                setTo(const String16& other);
            status_t            setTo(const char16_t* other);
            status_t            setTo(const char16_t* other, size_t len);
            status_t            setTo(const String16& other,
                                      size_t len,
                                      size_t begin=0);

            status_t            append(const String16& other);
            status_t            append(const char16_t* other, size_t len);

    inline  String16&           operator=(const String16& other);
            String16&           operator=(String16&& other) noexcept;

    inline  String16&           operator+=(const String16& other);
    inline  String16            operator+(const String16& other) const;

            status_t            insert(size_t pos, const char16_t* chrs);
            status_t            insert(size_t pos,
                                       const char16_t* chrs, size_t len);

            ssize_t             findFirst(char16_t c) const;
            ssize_t             findLast(char16_t c) const;

            bool                startsWith(const String16& prefix) const;
            bool                startsWith(const char16_t* prefix) const;

            bool                contains(const char16_t* chrs) const;

            status_t            replaceAll(char16_t replaceThis,
                                           char16_t withThis);

    inline  int                 compare(const String16& other) const;

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

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

    inline                      operator const char16_t*() const;
            bool                isStaticString() const;

  private:
    static constexpr uint32_t kIsSharedBufferAllocated = 0x80000000;

    /*
     * alloc() returns void* so that SharedBuffer class is not exposed.
     */
    static void* alloc(size_t size);
    static char16_t* allocFromUTF8(const char* u8str, size_t u8len);
    static char16_t* allocFromUTF16(const char16_t* u16str, size_t u16len);
    void* edit();
    void* editResize(size_t new_size);

    void acquire();
    void release();

    size_t staticStringSize() const;

    const char16_t* mString;

protected:
    template <size_t N>
    struct StaticData {
        // The high bit of 'size' is used as a flag.
        static_assert(N - 1 < kIsSharedBufferAllocated, "StaticString16 too long!");
        constexpr StaticData() : size(N - 1), data{0} {}
        const uint32_t size;
        char16_t data[N];

        constexpr StaticData(const StaticData<N>&) = default;
    };

    /*
     * Helper function for constructing a StaticData object.
     */
    template <size_t N>
    static constexpr const StaticData<N> makeStaticData(const char16_t (&s)[N]) {
        StaticData<N> r;
        for (size_t i = 0; i < N - 1; ++i) r.data[i] = s[i];
        return r;
    }

    template <size_t N>
    explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
};

重点关注下： String16(const String16& o);构造函数实现

<3>.String16构造函数

system/core/libutils/String16.cpp

String16::String16(const String16& o) : mString(o.mString)
{
    acquire();
}

将传入的String16对象变量o，将o.mString赋值给mString类成员变量，mString的定义如下所示。

const char16_t* mString;

char16_t类型占2个byte。