字符串处理小写字母转换大写字母

我来为你提供 Python、C++、Rust 的实现：

Python 实现

def process_string(s: str) -> tuple[str, int]:
    """
    将字符串中的小写字母转换为大写，并统计小写字母个数
    
    Args:
        s: 输入字符串
        
    Returns:
        tuple[转换后的字符串, 小写字母个数]
    """
    lowercase_count = 0
    result_chars = []
    
    for ch in s:
        if 'a' <= ch <= 'z':
            result_chars.append(chr(ord(ch) - 32))  # 小写转大写
            lowercase_count += 1
        else:
            result_chars.append(ch)  # 其他字符保持不变
            
    return ''.join(result_chars), lowercase_count


# 更简洁的 Pythonic 写法
def process_string_pythonic(s: str) -> tuple[str, int]:
    lowercase_count = sum(1 for ch in s if 'a' <= ch <= 'z')
    result = ''.join(ch.upper() if 'a' <= ch <= 'z' else ch for ch in s)
    return result, lowercase_count


# 测试
if __name__ == "__main__":
    text = "Hello World! 123"
    result, count = process_string(text)
    print(f"输入: {text}")
    print(f"输出: {result}")
    print(f"小写字母数: {count}")

C++ 实现

#include <iostream>
#include <string>
#include <cctype>  // 用于 islower 和 toupper
#include <utility> // 用于 pair

std::pair<std::string, int> processString(const std::string& input) {
    std::string result;
    int lowercaseCount = 0;
    
    // 预分配空间，提高效率
    result.reserve(input.length());
    
    for (char ch : input) {
        if (islower(ch)) {
            result.push_back(toupper(ch));  // 小写转大写
            ++lowercaseCount;
        } else {
            result.push_back(ch);  // 其他字符保持不变
        }
    }
    
    return {result, lowercaseCount};
}

// 使用传统指针的 C 风格实现
void processStringCstyle(const char* input, char* output, int* lowercaseCount) {
    *lowercaseCount = 0;
    
    for (int i = 0; input[i] != '\0'; ++i) {
        char ch = input[i];
        if (ch >= 'a' && ch <= 'z') {
            output[i] = ch - 32;  // 小写转大写
            ++(*lowercaseCount);
        } else {
            output[i] = ch;
        }
    }
    output[strlen(input)] = '\0';  // 字符串结束符
}

// 测试
int main() {
    std::string text = "Hello World! 123";
    
    auto [result, count] = processString(text);
    
    std::cout << "输入: " << text << std::endl;
    std::cout << "输出: " << result << std::endl;
    std::cout << "小写字母数: " << count << std::endl;
    
    return 0;
}

Rust 实现

fn process_string(s: &str) -> (String, usize) {
    let mut result = String::with_capacity(s.len());
    let mut lowercase_count = 0;
    
    for ch in s.chars() {
        if ch.is_ascii_lowercase() {
            // 小写字母转大写
            result.push(ch.to_ascii_uppercase());
            lowercase_count += 1;
        } else {
            // 其他字符保持不变
            result.push(ch);
        }
    }
    
    (result, lowercase_count)
}

// 更函数式的 Rust 实现
fn process_string_functional(s: &str) -> (String, usize) {
    let lowercase_count = s.chars().filter(|c| c.is_ascii_lowercase()).count();
    
    let result = s.chars()
        .map(|c| {
            if c.is_ascii_lowercase() {
                c.to_ascii_uppercase()
            } else {
                c
            }
        })
        .collect();
    
    (result, lowercase_count)
}

// 测试
fn main() {
    let text = "Hello World! 123";
    
    let (result, count) = process_string(text);
    
    println!("输入: {}", text);
    println!("输出: {}", result);
    println!("小写字母数: {}", count);
}

// 单元测试
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_process_string() {
        assert_eq!(process_string("Hello"), ("HELLO".to_string(), 4));
        assert_eq!(process_string("123"), ("123".to_string(), 0));
        assert_eq!(process_string("aBcDeF"), ("ABCDEF".to_string(), 3));
        assert_eq!(process_string(""), ("".to_string(), 0));
    }
}

各语言特点对比

特性 Python C++ Rust

字符串类型 不可变 Unicode std::string（可变） String（可变），&str（不可变切片）

内存管理 自动垃圾回收 手动/RAII 所有权系统

函数返回 元组 (str, int) pair<string, int> 元组 (String, usize)

字符处理 内置方法 .upper() 标准库函数 toupper() 方法 .to_ascii_uppercase()

空安全 运行时检查 无（可能空指针） 编译时保证（Option类型）

性能特点 简洁但较慢 高效，接近硬件 零成本抽象，内存安全

运行示例

输入: "Hello World! 123"
输出: "HELLO WORLD! 123"
小写字母数: 8

解释：

· "Hello World!" 中有 8 个小写字母（e,l,l,o,o,r,l,d）

· 数字和标点符号保持不变

· 原本的大写字母 H、W 保持不变