cstring::find 返回值

`std::string::find` 函数是用来在一个字符串中查找另一个子字符串的位置，如果找到了则返回该子字符串第一次出现的位置，如果没有找到则返回 `std::string::npos`。`std::string::npos` 是一个静态常量，它的值是一个表示无效或未找到位置的特殊值，通常是一个极大的整数值（例如 `std::string::npos` 在大多数实现中被定义为 `-1`）。因此，如果 `find` 函数返回的是 `std::string::npos`，则说明没有找到该子字符串。

相关问题

CString GetSensorConfigString(CString strSection, CString strKey, CString strFile, CString strDefault) { TCHAR strValue[MAX_PATH]; CString strConfig; int num; num = GetPrivateProfileString(strSection, strKey, _T(""), strValue, MAX_PATH, strFile); if(num > 0) strConfig = strValue; else strConfig = strDefault; int pos = strConfig.Find(_T("//")); if(pos > 0) strConfig = strConfig.Left(pos); strConfig = strConfig.Trim(); return strConfig; }

这是一个用于获取传感器配置字符串的函数。函数的参数包括`strSection`（配置文件中的节名称）、`strKey`（配置文件中的键名称）、`strFile`（配置文件的路径）、`strDefault`（默认值）。

函数首先定义了一个名为`strValue`的字符数组，用于存储从配置文件中获取的值。然后创建了一个空的`CString`对象`strConfig`，用于存储最终的配置字符串。

接下来，函数调用了`GetPrivateProfileString`函数，从配置文件中获取指定节和键的值，并将其存储在`strValue`中。如果成功获取到值（即返回值大于0），则将其赋值给`strConfig`，否则将`strDefault`赋值给`strConfig`。

之后，函数使用`Find`函数查找`strConfig`中是否包含"//"，如果存在，则将其之后的内容截取掉。最后，使用`Trim`函数去除字符串两端的空格，并将最终结果返回。

请注意，这段代码使用了MFC（Microsoft Foundation Classes）中的CString类和相关函数。

基于char* 设计一个字符串类MyString，具有构造函数、析构函数、复制构造函数。具体如下： MyString(); MyString(const char* cString); char at(int index) const; int length() const; void clear(); bool empty() const; int compare(const MyString& s) const; int compare(int index, int n, const MyString& s) const; void copy(char s[], int index , int n); char* data() const; int find(char ch) const ; int find(char ch ,int index) const; int find(const MyString& s, int index) const;

好的，以下是基于 char* 设计的 MyString 类的实现：

class MyString {
public:
    // 构造函数
    MyString();
    MyString(const char* cString);
    // 复制构造函数
    MyString(const MyString& other);
    // 析构函数
    ~MyString();

    // 获取指定下标的字符
    char at(int index) const;

    // 获取字符串的长度
    int length() const;

    // 清空字符串
    void clear();

    // 判断字符串是否为空
    bool empty() const;

    // 比较两个字符串，返回值为负数、0、正数表示当前字符串小于、等于、大于另一个字符串
    int compare(const MyString& s) const;

    // 比较当前字符串的子串和另一个字符串，返回值为负数、0、正数表示当前字符串小于、等于、大于另一个字符串
    int compare(int index, int n, const MyString& s) const;

    // 将当前字符串的子串复制到指定数组中
    void copy(char s[], int index , int n);

    // 获取当前字符串的 char* 形式
    char* data() const;

    // 查找指定字符在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(char ch) const;

    // 从指定下标开始查找指定字符在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(char ch, int index) const;

    // 从指定下标开始查找指定字符串在当前字符串中第一次出现的位置，若不存在返回 -1
    int find(const MyString& s, int index) const;

private:
    char* m_data; // 字符串的实际存储空间
    int m_length; // 字符串的长度
};

下面是 MyString 类的实现：

MyString::MyString() {
    m_data = new char[1];
    m_data[0] = '\0';
    m_length = 0;
}

MyString::MyString(const char* cString) {
    if (cString == nullptr) {
        m_data = new char[1];
        m_data[0] = '\0';
        m_length = 0;
    } else {
        m_length = strlen(cString);
        m_data = new char[m_length + 1];
        strcpy(m_data, cString);
    }
}

MyString::MyString(const MyString& other) {
    m_length = other.m_length;
    m_data = new char[m_length + 1];
    strcpy(m_data, other.m_data);
}

MyString::~MyString() {
    delete[] m_data;
}

char MyString::at(int index) const {
    if (index < 0 || index >= m_length) {
        return '\0';
    }
    return m_data[index];
}

int MyString::length() const {
    return m_length;
}

void MyString::clear() {
    delete[] m_data;
    m_data = new char[1];
    m_data[0] = '\0';
    m_length = 0;
}

bool MyString::empty() const {
    return m_length == 0;
}

int MyString::compare(const MyString& s) const {
    return strcmp(m_data, s.m_data);
}

int MyString::compare(int index, int n, const MyString& s) const {
    if (index < 0 || index >= m_length) {
        return -1;
    }
    if (n < 0 || n > m_length - index) {
        return -1;
    }
    char* subStr = new char[n + 1];
    strncpy(subStr, m_data + index, n);
    subStr[n] = '\0';
    int result = strcmp(subStr, s.m_data);
    delete[] subStr;
    return result;
}

void MyString::copy(char s[], int index , int n) {
    if (index < 0 || index >= m_length) {
        return;
    }
    if (n < 0 || n > m_length - index) {
        return;
    }
    strncpy(s, m_data + index, n);
    s[n] = '\0';
}

char* MyString::data() const {
    char* result = new char[m_length + 1];
    strcpy(result, m_data);
    return result;
}

int MyString::find(char ch) const {
    char* p = strchr(m_data, ch);
    if (p == nullptr) {
        return -1;
    }
    return p - m_data;
}

int MyString::find(char ch, int index) const {
    if (index < 0 || index >= m_length) {
        return -1;
    }
    char* p = strchr(m_data + index, ch);
    if (p == nullptr) {
        return -1;
    }
    return p - m_data;
}

int MyString::find(const MyString& s, int index) const {
    if (index < 0 || index >= m_length) {
        return -1;
    }
    char* p = strstr(m_data + index, s.m_data);
    if (p == nullptr) {
        return -1;
    }
    return p - m_data;
}