C代写：COMP2129 String Manipulation and Compiler Workflow in Depth

深入讲解C语言字符串操作与编译器工作流程，涵盖结构化编程规范、字符串函数实现、编译链接原理及任务管理器项目实践。

Best Practices for Structured C Programming

Developing maintainable C programs requires adherence to proven software engineering principles:

1. Semantic Naming Conventions
   Select identifiers that reveal intent (e.g., calculate_checksum() vs calc()). Comments should explain “why” rather than “what”.

2. DRY Principle Enforcement
   Extract repeated logic into functions. For example, instead of multiple strlen() checks, create a validate_string_length() helper.

3. Function Granularity
   The Linux kernel style guide recommends functions shouldn’t exceed 40 lines. Each function should have single responsibility.

4. Conciseness Over Cleverness
   Favor straightforward implementations. For example:

   // Preferred
   for (int i = 0; i < MAX_ITER; i++) {
       process_item(items[i]);
   }
   
   // Overly clever
   while (MAX_ITER--) process_item(*items++);

5. Immutability Where Possible
   Mark parameters as const when unchanged:

   size_t safe_strlen(const char *str) {
       // str cannot be modified
   }

6. Standard Library Utilization
   Common pitfalls when reinventing standard functions:

   • Manual string copying (use strncpy())
   • Custom sorting (use qsort())
   • Memory management errors (use calloc() over manual zeroing)

7. Convention Compliance
   Follow established patterns:

   • i,j,k for loop counters
   • ptr suffix for pointers
   • _t suffix for types

8. Consistency Across Codebase
   Enforce uniform:

   • Brace style (Allman vs K&R)
   • Indentation (spaces vs tabs)
   • Naming (camelCase vs snake_case)

Essential Reading Materials

• “Clean Code: A Handbook of Agile Software Craftsmanship” by Robert Martin
• “Effective C: An Introduction to Professional C Programming” by Robert Seacord
• “Expert C Programming: Deep C Secrets” by Peter van der Linden
• “The Linux Programming Interface” by Michael Kerrisk
• “Secure Coding in C and C++” by Robert Seacord

---

Comprehensive String Handling in C

The C standard library (C11) provides these critical string operations:

#include <ctype.h>
int isalnum(int c); // Alphanumeric check
int tolower(int c); // Case conversion

#include <stdlib.h>
double strtod(const char *nptr, char **endptr); // Advanced number parsing
long strtol(const char *nptr, char **endptr, int base); // Base conversion

#include <string.h>
char *strncpy(char *dest, const char *src, size_t n); // Bounded copy
size_t strnlen(const char *s, size_t maxlen); // Safe length check
char *strstr(const char *haystack, const char *needle); // Substring search

GNU extensions (compile with -std=gnu11) add:

char *strchrnul(const char *s, int c); // Like strchr but returns end pointer
void *memmem(const void *haystack, size_t hlen, const void *needle, size_t nlen); // Binary search
char *strerror_r(int errnum, char *buf, size_t buflen); // Thread-safe error strings

---

Practical Exercise: Implementing Core String Functions

Task 1: Building Standard Library Equivalents

Implement these fundamental string operations from scratch:

1. String Length (strlen)
   Key considerations:

   • Null-terminator handling
   • Pointer arithmetic
   • Optimization opportunities

2. String Copy (strcpy)
   Must handle:

   • Destination buffer overflow
   • Source/destination overlap
   • Return value semantics

3. Tokenization (strtok)
   Implementation challenges:

   • State maintenance between calls
   • Multiple delimiter handling
   • Thread safety considerations

Example implementation approach:

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p) p++;
    return p - s;
}

---

Understanding the Compilation Pipeline

Makefile Deep Dive

A robust build configuration:

CC = gcc
CFLAGS = -Og -g3 -Wall -Wextra -pedantic -fsanitize=address
LDFLAGS = -fsanitize=address
TARGET = string_processor

.PHONY: debug release clean

debug: CFLAGS += -DDEBUG -fstack-protector
debug: $(TARGET)

release: CFLAGS += -O2 -flto -DNDEBUG
release: $(TARGET)

$(TARGET): main.o utils.o
	$(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)

%.o: %.c
	$(CC) -c $(CFLAGS) $< -o $@

clean:
	rm -f *.o $(TARGET)

Preprocessor Exploration

Key directives:

1. Conditional Compilation

   #ifdef DEBUG
   #define LOG(msg) fprintf(stderr, "[DEBUG] %s\n", msg)
   #else
   #define LOG(msg)
   #endif

2. Macro Pitfalls
   Dangerous macro:

   #define SQUARE(x) x * x
   // SQUARE(1+1) expands to 1+1*1+1 = 3

   Safe version:

   #define SQUARE(x) ((x) * (x))

Assembly Generation

Examining compiler output:

$ gcc -S -fverbose-asm -o main.s main.c
$ objdump -d -M intel -S main.o > main.disasm

Key observations:

• Optimization levels dramatically affect output
• Debug symbols enable source correlation
• Architecture-specific instructions appear

Linking Process

Critical concepts:

1. Symbol Resolution
   The linker matches:

   • External declarations (.h files)
   • Actual definitions (.c files)

2. Visibility Control

   • static limits scope to translation unit
   • extern enables cross-file usage

3. Common Issues

   • Undefined references
   • Multiple definitions
   • Version conflicts

---

Advanced Exercise: Task Manager Application

Requirements Specification

1. File I/O Operations

   • Implement robust file reading with error handling
   • Use dynamic memory for variable-length lines
   • Handle CRLF/LF line endings

2. Command Processing
   Sample interface:

   > add "Complete memory exercise"
   Added task 4
   > move 4 before 2
   Moved task
   > delete completed
   Removed 3 tasks

3. Undo Functionality
   Architectural options:

   • Command pattern with history stack
   • Memento pattern for state snapshots
   • Persistent transaction log

4. Memory Management
   Required strategies:

   • Reference counting for shared strings
   • Memory pooling for task nodes
   • Sanitizer integration for leak detection

Implementation Guidance

1. Data Structures

   typedef struct {
       char *description;
       time_t created;
       uint8_t priority;
   } task_t;
   
   typedef struct node {
       task_t *task;
       struct node *next, *prev;
   } node_t;

2. Error Handling

   #define TRY(expr) \    if (!(expr)) { \        fprintf(stderr, "Error in %s:%d", __FILE__, __LINE__); \        goto cleanup; \    }
       if (!(expr)) { \
           fprintf(stderr, "Error in %s:%d", __FILE__, __LINE__); \
           goto cleanup; \
       }
   
   void load_tasks() {
       FILE *fp = NULL;
       TRY(fp = fopen("tasks.txt", "r"));
       // ...
   cleanup:
       if (fp) fclose(fp);
   }

3. Interactive Loop

   while (fgets(buf, sizeof(buf), stdin)) {
       char *cmd = strtok(buf, " \n");
       if (!strcmp(cmd, "add")) {
           handle_add_command(strtok(NULL, "\n"));
       }
       // ...
   }