使用自定义结构和指针进行字符串比较和深度复制

Question

我目前正在尝试在不使用string.h 库的情况下为自定义字符串结构编写一堆函数，但是在我的几个函数中实现我的结构时遇到了一些困难——特别是copy_string(...)和compare_string(...)。本质上，这两个函数应该与 C 中的 strcpy(...) 和 strcmp(...) 做同样的事情，但我希望它们与下面定义的基本 String 对象一起工作。

这是结构本身：

struct _String {

   char     *letters; // dynamically-allocated array to hold the characters
   uint32_t  count;   // number of characters in the string
};
typedef struct _String String;

/* IMPORTANT NOTE:
 *    String object S:
 *
 *    S.letters points to an array of dimension S.count + 1 and S.letters[S.count] == '\0'.
 *    If S.count > 0, then S.letters[0:S.count-1] hold the character letters for the string.
 */

这是我当前对 copy_string 的实现，其中 cmets 描述了我希望我的函数做什么：

/** Makes an exact, full copy of a String.
*
* Pre:
*    *target is a String object
*    *source is a String object
*    target != source
* Post:
*    no memory leaks have occurred and
*    *target is a deep copy of *source
*    target->count = source->count
*    target->letters[i] == source->letters[i], i = 0 to target->count
*    target->letters != source->letters
*    *target is a String object
*
* Returns:
*    the count of target->letters
*    a negative value, if some error occurs
*/
int32_t copy_string(String* const target, const String* const source) {

    // int8_t count = 0;
    // while (source->letters[count] != '\0') { }

    if (source->letters == NULL)
        return -1;

    int i = 0;

    while (source->letters[i] != '\0') {

        target->letters[i] = source->letters[i];
        i++;

    }

    target->letters[target->count] = '\0';
    target->count = source->count;

    if (target->letters == NULL)
        return -2;

    return target->count;

}

这是我当前对 compare_string 的实现，其中 cmets 描述了我希望我的函数执行的操作：

/** Compares two Strings.
 * 
 *  Pre:
 *    *first is a String object
 *    *second is a String object
 *
 *  Returns:
 *    < 0 if first precedes second based on ASCII values
 *      0 if first equals second
 *    > 0 if first follows second based on ASCII values
 */
int32_t compare_string(const String* const first, const String* const second) {

    while (first->letters && (first->letters == second->letters))
        first++, second++; // impossible due to const qualifiers

    return first->letters - second->letters    
}

我遇到了编译错误，例如“成员 count 是只读对象”、内存泄漏以及其他与指针相关的问题。我实际上是在四个星期前开始学习 C 的，所以请多多包涵。任何批评和/或帮助都会很棒。

（更新）这是string_compare 应该如何工作的示例：第一个字符串是“cat”，第二个字符串是“elephant”。该函数应通过使用 > 或

Answer 1

在copy_string() 函数中，您指的是变量target->count 在分配之前。将两句顺序切换为：

target->count = source->count;
target->letters[target->count] = '\0';

在compare_string() 函数中，您的代码：

for (int i = 0; i < first->count; i++) {
    if (*(first->letters + i) == *(second->letters + i))
        return 0;
}

仅在比较第一个字符后返回0立即。
请尝试以下方法：

int32_t compare_string(const String* const first, const String* const second) {

    int32_t i;
    while (1) {
        int32_t c1 = first->letters[i];
        int32_t c2 = second->letters[i];
        if (!c1) {              // end of string "first"
            if (!c2) {          // end of string "second", too
                break;          // both "first" and "second" ends
            } else {
                return -c2;     // "first" ends before "second"
            }
        } else if (!c2) {       // "second" ends before "first"
            return c1;
        } else if (c1 != c2) {  // the characters differ
            return c1 - c2;     // return the difference
        }
        i++;
    }

    return 0;                   // exact match
}

从您的评论来看，内存泄漏似乎不是您的责任。