C语言 StringBuilder

在C语言中，没有内置的StringBuilder类型，但可以通过使用字符数组和字符串拼接的方式来实现类似StringBuilder的功能。

下面是一个简单的实现示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char str[100] = "";
    char buffer[10];
    int num = 12345;
    
    // 将一个整数转换为字符串并追加到str中
    sprintf(buffer, "%d", num);
    strcat(str, buffer);
    
    // 将一个字符串追加到str中
    strcat(str, " is a number.");
    
    printf("%s", str);
    return 0;
}

在上面的示例中，我们使用了sprintf函数将一个整数转换为字符串，并使用strcat函数将其追加到一个字符数组中。使用类似的方式，我们可以将任意类型的数据转换为字符串并追加到一个字符数组中，从而实现类似StringBuilder的功能。

相关问题

C#清空stringbuilder

C是一种高级程序语言，它是由美国计算机科学家丹尼斯·里奇（Dennis Ritchie）在1972年发明的。C语言被广泛应用于系统软件开发、嵌入式系统和网络应用程序等领域，是一种强大而高效的编程语言。C语言具有良好的可移植性、高效性和灵活性，因此成为了编程语言中的主流之一。C语言产生了许多衍生语言，例如C++、Objective-C等。

c语言词法分析器java

实现一个C语言词法分析器的Java代码，可以参考以下步骤：

1. 定义一个Token类，用于表示词法单元的类型和对应的值。

public class Token {
    private TokenType type;
    private String value;

    public Token(TokenType type, String value) {
        this.type = type;
        this.value = value;
    }

    public TokenType getType() {
        return type;
    }

    public String getValue() {
        return value;
    }

    @Override
    public String toString() {
        return String.format("(%s, %s)", type, value);
    }
}

2. 定义一个TokenType枚举类，用于表示所有可能的词法单元类型。

public enum TokenType {
    KEYWORD, IDENTIFIER, CONSTANT, STRING_LITERAL, OPERATOR, PUNCTUATOR
}

3. 实现词法分析器的核心逻辑，包括读取源代码、识别词法单元并返回Token对象等。

public class Lexer {
    private String input;
    private int position;

    public Lexer(String input) {
        this.input = input;
        this.position = 0;
    }

    public Token getNextToken() {
        if (position >= input.length()) {
            return null;
        }

        char currentChar = input.charAt(position);

        if (isLetter(currentChar)) {
            return scanIdentifier();
        }

        if (isDigit(currentChar)) {
            return scanNumber();
        }

        if (currentChar == '\"') {
            return scanStringLiteral();
        }

        if (isOperator(currentChar)) {
            return scanOperator();
        }

        if (isPunctuator(currentChar)) {
            return scanPunctuator();
        }

        throw new IllegalArgumentException("Invalid character: " + currentChar);
    }

    private boolean isLetter(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }

    private boolean isDigit(char c) {
        return c >= '0' && c <= '9';
    }

    private boolean isOperator(char c) {
        return "+-*/%=&|<>!".indexOf(c) != -1;
    }

    private boolean isPunctuator(char c) {
        return "()[]{};,".indexOf(c) != -1;
    }

    private Token scanIdentifier() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && (isLetter(input.charAt(position)) || isDigit(input.charAt(position)))) {
            sb.append(input.charAt(position));
            position++;
        }

        String value = sb.toString();
        TokenType type = TokenType.IDENTIFIER;

        if (isKeyword(value)) {
            type = TokenType.KEYWORD;
        }

        return new Token(type, value);
    }

    private boolean isKeyword(String value) {
        String[] keywords = {"auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else",
                "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed",
                "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while"};
        return Arrays.asList(keywords).contains(value);
    }

    private Token scanNumber() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && isDigit(input.charAt(position))) {
            sb.append(input.charAt(position));
            position++;
        }

        return new Token(TokenType.CONSTANT, sb.toString());
    }

    private Token scanStringLiteral() {
        StringBuilder sb = new StringBuilder();

        position++; // skip the opening quotation mark

        while (position < input.length() && input.charAt(position) != '\"') {
            sb.append(input.charAt(position));
            position++;
        }

        position++; // skip the closing quotation mark

        return new Token(TokenType.STRING_LITERAL, sb.toString());
    }

    private Token scanOperator() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && isOperator(input.charAt(position))) {
            sb.append(input.charAt(position));
            position++;
        }

        return new Token(TokenType.OPERATOR, sb.toString());
    }

    private Token scanPunctuator() {
        Token token = new Token(TokenType.PUNCTUATOR, String.valueOf(input.charAt(position)));
        position++;
        return token;
    }
}

4. 编写一个测试程序，用于读取输入的源代码，调用词法分析器并输出词法单元。

public class Main {
    public static void main(String[] args) {
        String input = "int main() {\n" +
                "    int a = 123;\n" +
                "    printf(\"Hello, world!\\n\");\n" +
                "    return 0;\n" +
                "}";

        Lexer lexer = new Lexer(input);

        Token token;
        while ((token = lexer.getNextToken()) != null) {
            System.out.println(token);
        }
    }
}

输出结果如下：

(KEYWORD, int)
(IDENTIFIER, main)
(PUNCTUATOR, ()
(PUNCTUATOR, ))
(PUNCTUATOR, {)
(KEYWORD, int)
(IDENTIFIER, a)
(PUNCTUATOR, =)
(CONSTANT, 123)
(PUNCTUATOR, ;)
(IDENTIFIER, printf)
(PUNCTUATOR, ()
(STRING_LITERAL, Hello, world!\n)
(PUNCTUATOR, ))
(PUNCTUATOR, ;)
(KEYWORD, return)
(CONSTANT, 0)
(PUNCTUATOR, ;)
(PUNCTUATOR, })