ppp::string GetCommandArgument(int argc, const char** argv) noexcept {
    // 參數(shù)合法性檢查：確保argv非空且參數(shù)數(shù)量有效
    if (NULL == argv || argc <= 1) {
        return "";  // 參數(shù)不足時返回空字符串
    }
    
    ppp::string line;  // 用于存儲整合后的命令行字符串
    
    // 遍歷所有參數(shù)（從索引1開始，跳過程序名）
    for (int i = 1; i < argc; i++) {
        line.append(RTrim(LTrim<ppp::string>(argv[i])));  // 去除參數(shù)兩端空白字符后追加
        line.append(" ");  // 參數(shù)間添加空格分隔符
    }
    
    return line;  // 返回整合后的命令行字符串
}

bool HasCommandArgument(const char* name, int argc, const char** argv) noexcept {
    // 第一步：參數(shù)有效性驗證
    if (NULL == name || *name == '\x0') {  // 檢查名稱是否為空指針或空字符串
        return false;  // 無效參數(shù)名直接返回false
    }
    
    // 第二步：獲取完整命令行文本
    ppp::string commandText = ppp::GetCommandArgument(argc, argv);
    if (commandText.empty()) {  // 檢查命令行是否為空
        return false;  // 無參數(shù)時直接返回false
    }
    
    // 第三步：定義內(nèi)部查找lambda函數(shù)
    auto fx = ppp::string& commandText, const ppp::string& name noexcept -> bool {
        // 在命令行文本中查找參數(shù)名
        std::size_t index = commandText.find(name);
        if (index == ppp::string::npos) {  // 未找到目標字符串
            return false;
        }
        
        // 檢查參數(shù)名位置是否合法（行首或前面有空格）
        if (index == 0) {  // 參數(shù)位于行首
            return true;
        }
        
        char ch = commandText[index - 1];  // 獲取參數(shù)名前一個字符
        if (ch == ' ') {  // 前一個字符是空格，表明是獨立參數(shù)
            return true;
        } else {
            return false;  // 前一個字符不是空格，可能是其他參數(shù)的一部分
        }
    };
    
    // 第四步：使用兩種格式檢查參數(shù)存在性
    bool result = false;  // 初始化結(jié)果為false
    ppp::string keyWithEqual = name + ppp::string("=");  // 構(gòu)造"name="格式的鍵
    ppp::string keyWithSpace = name + ppp::string(" ");  // 構(gòu)造"name "格式的鍵
    
    // 檢查兩種可能的參數(shù)格式
    result = result || fx(commandText, keyWithEqual);  // 檢查"--name="格式
    result = result || fx(commandText, keyWithSpace);  // 檢查"--name "格式
    
    return result;  // 返回最終檢測結(jié)果
}

ppp::string GetCommandArgument(const char* name, int argc, const char** argv) noexcept {
    // 第一階段：參數(shù)驗證和初始化
    if (NULL == name || argc <= 1) {  // 檢查名稱指針和參數(shù)數(shù)量
        return "";  // 基本驗證失敗返回空字符串
    }
    
    ppp::string key1 = name;  // 創(chuàng)建參數(shù)名副本
    if (key1.empty()) {  // 檢查參數(shù)名是否為空
        return "";  // 空參數(shù)名返回空字符串
    }
    
    // 構(gòu)造兩種查找鍵格式
    ppp::string key2 = key1 + " ";  // "name "格式，用于空格分隔的參數(shù)
    key1.append("=");  // "name="格式，用于等號連接的值
    
    // 獲取完整命令行文本
    ppp::string line = GetCommandArgument(argc, argv);
    if (line.empty()) {  // 檢查命令行是否為空
        return "";  // 空命令行返回空字符串
    }
    
    // 第二階段：查找參數(shù)位置
    ppp::string* key = addressof(key1);  // 首先嘗試"name="格式
    std::size_t L = line.find(*key);  // 查找鍵出現(xiàn)位置
    
    if (L == ppp::string::npos) {  // 第一種格式未找到
        key = addressof(key2);  // 切換到"name "格式
        L = line.find(*key);  // 重新查找
        if (L == ppp::string::npos) {  // 第二種格式也未找到
            return "";  // 參數(shù)不存在返回空字符串
        }
    }
    
    // 第三階段：驗證參數(shù)名完整性
    if (L) {  // 參數(shù)名不是行首位置（L > 0）
        char ch = line[L - 1];  // 檢查參數(shù)名前字符
        if (ch != ' ') {  // 前一個字符不是空格
            return "";  // 說明不是獨立參數(shù)名，返回空
        }
    }
    
    // 第四階段：提取參數(shù)值
    ppp::string cmd;  // 存儲提取的結(jié)果值
    std::size_t M = L + key->size();  // 計算值開始位置（鍵結(jié)束位置）
    std::size_t R = line.find(' ', L);  // 查找下一個空格位置
    
    if (M >= R) {  // 處理無空格的情況（參數(shù)值可能為空或到行尾）
        R = ppp::string::npos;  // 標記為未找到空格
        
        // 手動查找值結(jié)束位置
        for (std::size_t I = M, SZ = line.size(); I < SZ; I++) {
            int ch = line[I];  // 遍歷每個字符
            if (ch == ' ') {  // 找到空格
                R = I;  // 記錄結(jié)束位置
                L = M;  // 調(diào)整開始位置
                break;  // 退出循環(huán)
            }
        }
        
        if (!L || L == ppp::string::npos) {  // 位置驗證失敗
            return "";  // 返回空字符串
        }
    }
    
    // 第五階段：根據(jù)找到的位置提取子字符串
    if (R == ppp::string::npos) {  // 沒有找到后續(xù)空格（值到行尾）
        if (M != line.size()) {  // 確保值開始位置有效
            cmd = line.substr(M);  // 提取從M到末尾的子字符串
        }
    } else {  // 找到了值結(jié)束位置
        int S = (int)(R - M);  // 計算值長度
        if (S > 0) {  // 長度有效
            cmd = line.substr(M, S);  // 提取指定長度的子字符串
        }
    }
    
    return cmd;  // 返回提取的參數(shù)值
}

// 布爾值獲取函數(shù)：將參數(shù)值轉(zhuǎn)換為布爾類型
bool GetCommandArgument(const char* name, int argc, const char** argv, bool defaultValue) noexcept {
    // 獲取字符串形式的參數(shù)值
    ppp::string str = GetCommandArgument(name, argc, argv);
    if (str.empty()) {  // 值為空時返回默認值
        return defaultValue;
    }
    
    // 將字符串轉(zhuǎn)換為布爾值
    return ToBoolean(str.data());  // 調(diào)用轉(zhuǎn)換函數(shù)
}

// 字符串獲取函數(shù)（C字符串默認值版本）
ppp::string GetCommandArgument(const char* name, int argc, const char** argv, const char* defaultValue) noexcept {
    ppp::string defValue;  // 創(chuàng)建默認值字符串
    if (defaultValue) {  // 檢查默認值指針是否有效
        defValue = defaultValue;  // 賦值默認值
    }
    
    // 調(diào)用主獲取函數(shù)，傳入默認值
    return GetCommandArgument(name, argc, argv, defValue);
}

// 字符串獲取函數(shù)（字符串對象默認值版本）
ppp::string GetCommandArgument(const char* name, int argc, const char** argv, const ppp::string& defaultValue) noexcept {
    // 獲取參數(shù)值
    ppp::string str = GetCommandArgument(name, argc, argv);
    // 三目運算符：值為空時返回默認值，否則返回實際值
    return str.empty() ? defaultValue : str;
}

bool IsInputHelpCommand(int argc, const char* argv[]) noexcept {
    // 定義支持的幫助命令列表
    const int HELP_COMMAND_COUNT = 4;  // 幫助命令數(shù)量
    const char* HELP_COMMAND_LIST[HELP_COMMAND_COUNT] = {
        "-h",      // 短格式簡寫
        "--h",     // 長格式簡寫  
        "-help",   // 短格式完整
        "--help"   // 長格式完整
    };
    
    // 遍歷所有幫助命令進行檢測
    for (int i = 0; i < HELP_COMMAND_COUNT; i++) {
        const char* command = HELP_COMMAND_LIST[i];  // 獲取當(dāng)前檢測的命令
        if (HasCommandArgument(command, argc, argv)) {  // 檢查命令是否存在
            return true;  // 找到任一幫助命令即返回true
        }
    }
    
    return false;  // 未找到任何幫助命令返回false
}

#include <iostream>
#include "command_parser.h"  // 包含解析器頭文件

int main(int argc, const char** argv) {
    // 檢查幫助命令
    if (ppp::IsInputHelpCommand(argc, argv)) {
        std::cout << "用法: " << argv[0] << " [選項]" << std::endl;
        std::cout << "選項:" << std::endl;
        std::cout << "  --host=<地址>    服務(wù)器地址（必需）" << std::endl;
        std::cout << "  --port=<端口>    服務(wù)器端口（默認:8080）" << std::endl;
        std::cout << "  --verbose        啟用詳細輸出" << std::endl;
        return 0;
    }
    
    // 獲取必需參數(shù)
    std::string host = ppp::GetCommandArgument("--host", argc, argv, "");
    if (host.empty()) {
        std::cerr << "錯誤: 必須指定 --host 參數(shù)" << std::endl;
        return 1;
    }
    
    // 獲取可選參數(shù)（帶默認值）
    int port = ppp::GetCommandArgument("--port", argc, argv, 8080);
    bool verbose = ppp::GetCommandArgument("--verbose", argc, argv, false);
    
    // 應(yīng)用參數(shù)
    std::cout << "連接到 " << host << ":" << port << std::endl;
    if (verbose) {
        std::cout << "詳細模式已啟用" << std::endl;
    }
    
    // 程序主邏輯...
    return 0;
}