C++编程完全指南教你如何精确统计并高效输出数字的个数从基础语法到高级应用包含实际案例和代码示例助你快速掌握这一核心技能

威震华夏关云长

引言

在C++编程中，统计并输出数字的个数是一项基础而重要的技能。无论是在数据分析、游戏开发、科学计算还是日常编程任务中，我们经常需要处理各种数字数据，并对其进行统计。本文将从基础语法开始，逐步深入到高级应用，通过详细的代码示例和实际案例，帮助读者全面掌握这一核心技能。

基础语法部分

基本数据类型和变量

在C++中，数字主要分为整数和浮点数两大类。整数类型包括int、short、long和long long，而浮点数类型包括float、double和long double。了解这些基本数据类型是统计数字的第一步。

2. #include <iostream>
4. int main() {
5.     // 整数类型
6.     int a = 10;
7.     short b = 20;
8.     long c = 30000;
9.     long long d = 4000000000;
10.    
11.     // 浮点数类型
12.     float e = 3.14f;
13.     double f = 2.71828;
14.     long double g = 1.618033988749895;
15.    
16.     // 输出这些数字
17.     std::cout << "整数: " << a << ", " << b << ", " << c << ", " << d << std::endl;
18.     std::cout << "浮点数: " << e << ", " << f << ", " << g << std::endl;
19.    
20.     return 0;
21. }

复制代码

输入输出流

C++使用iostream库进行输入输出操作。std::cin用于输入，std::cout用于输出。下面是一个简单的例子，展示如何从用户输入中读取数字并输出：

2. #include <iostream>
4. int main() {
5.     int number;
6.     std::cout << "请输入一个整数: ";
7.     std::cin >> number;
8.     std::cout << "你输入的数字是: " << number << std::endl;
9.    
10.     return 0;
11. }

复制代码

基本计数方法

最简单的数字统计方法是使用计数器变量。下面是一个示例，统计用户输入的数字个数：

2. #include <iostream>
4. int main() {
5.     int count = 0;
6.     int number;
7.    
8.     std::cout << "请输入一系列整数，以任意非数字字符结束: " << std::endl;
9.    
10.     while (std::cin >> number) {
11.         count++;
12.     }
13.    
14.     std::cout << "你输入了 " << count << " 个数字。" << std::endl;
15.    
16.     return 0;
17. }

复制代码

在这个例子中，我们使用一个while循环和std::cin来读取用户输入的数字。每次成功读取一个数字，计数器count就会增加1。当用户输入非数字字符时，std::cin >> number会返回false，循环结束。

中级应用

数组中的数字统计

在实际编程中，我们经常需要统计数组中的数字个数。下面是一个示例，统计数组中特定数字的出现次数：

2. #include <iostream>
4. int main() {
5.     int numbers[] = {1, 2, 3, 4, 5, 2, 3, 2, 1, 6, 7, 8, 2};
6.     int size = sizeof(numbers) / sizeof(numbers[0]);
7.     int target = 2;
8.     int count = 0;
9.    
10.     for (int i = 0; i < size; i++) {
11.         if (numbers[i] == target) {
12.             count++;
13.         }
14.     }
15.    
16.     std::cout << "数字 " << target << " 在数组中出现了 " << count << " 次。" << std::endl;
17.    
18.     return 0;
19. }

复制代码

如果我们想统计数组中所有数字的出现次数，可以使用一个映射（map）来存储每个数字及其出现次数：

2. #include <iostream>
3. #include <map>
5. int main() {
6.     int numbers[] = {1, 2, 3, 4, 5, 2, 3, 2, 1, 6, 7, 8, 2};
7.     int size = sizeof(numbers) / sizeof(numbers[0]);
8.     std::map<int, int> frequency;
9.    
10.     for (int i = 0; i < size; i++) {
11.         frequency[numbers[i]]++;
12.     }
13.    
14.     std::cout << "数字出现频率统计:" << std::endl;
15.     for (const auto& pair : frequency) {
16.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
17.     }
18.    
19.     return 0;
20. }

复制代码

字符串中的数字统计

有时我们需要从字符串中提取并统计数字。下面是一个示例，统计字符串中的数字个数：

2. #include <iostream>
3. #include <string>
4. #include <cctype>
6. int main() {
7.     std::string str = "abc123def456ghi789jkl";
8.     int count = 0;
9.    
10.     for (char c : str) {
11.         if (isdigit(c)) {
12.             count++;
13.         }
14.     }
15.    
16.     std::cout << "字符串 "" << str << "" 中包含 " << count << " 个数字字符。" << std::endl;
17.    
18.     return 0;
19. }

复制代码

如果我们想提取并统计字符串中的完整数字（而不仅仅是数字字符），可以使用更复杂的方法：

2. #include <iostream>
3. #include <string>
4. #include <vector>
5. #include <sstream>
6. #include <map>
8. int main() {
9.     std::string str = "abc123def456ghi789jkl0mno42";
10.     std::vector<int> numbers;
11.     std::string currentNumber;
12.    
13.     for (char c : str) {
14.         if (isdigit(c)) {
15.             currentNumber += c;
16.         } else if (!currentNumber.empty()) {
17.             std::istringstream iss(currentNumber);
18.             int number;
19.             iss >> number;
20.             numbers.push_back(number);
21.             currentNumber.clear();
22.         }
23.     }
24.    
25.     // 处理字符串末尾的数字
26.     if (!currentNumber.empty()) {
27.         std::istringstream iss(currentNumber);
28.         int number;
29.         iss >> number;
30.         numbers.push_back(number);
31.     }
32.    
33.     std::cout << "从字符串中提取的数字: ";
34.     for (int num : numbers) {
35.         std::cout << num << " ";
36.     }
37.     std::cout << std::endl;
38.    
39.     std::cout << "共提取了 " << numbers.size() << " 个数字。" << std::endl;
40.    
41.     // 统计每个数字的出现频率
42.     std::map<int, int> frequency;
43.     for (int num : numbers) {
44.         frequency[num]++;
45.     }
46.    
47.     std::cout << "数字出现频率统计:" << std::endl;
48.     for (const auto& pair : frequency) {
49.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
50.     }
51.    
52.     return 0;
53. }

复制代码

文件中的数字统计

在实际应用中，我们经常需要从文件中读取数据并统计数字。下面是一个示例，统计文本文件中的数字个数：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
5. #include <vector>
6. #include <sstream>
8. int main() {
9.     std::ifstream file("numbers.txt");
10.     if (!file.is_open()) {
11.         std::cerr << "无法打开文件" << std::endl;
12.         return 1;
13.     }
14.    
15.     std::vector<int> numbers;
16.     std::string line;
17.    
18.     while (std::getline(file, line)) {
19.         std::istringstream iss(line);
20.         int number;
21.         
22.         while (iss >> number) {
23.             numbers.push_back(number);
24.         }
25.     }
26.    
27.     file.close();
28.    
29.     std::cout << "从文件中读取的数字: ";
30.     for (int num : numbers) {
31.         std::cout << num << " ";
32.     }
33.     std::cout << std::endl;
34.    
35.     std::cout << "文件中共有 " << numbers.size() << " 个数字。" << std::endl;
36.    
37.     return 0;
38. }

复制代码

如果我们想统计文件中每个数字的出现频率，可以使用以下代码：

2. #include <iostream>
3. #include <fstream>
4. #include <string>
5. #include <map>
6. #include <sstream>
8. int main() {
9.     std::ifstream file("numbers.txt");
10.     if (!file.is_open()) {
11.         std::cerr << "无法打开文件" << std::endl;
12.         return 1;
13.     }
14.    
15.     std::map<int, int> frequency;
16.     std::string line;
17.    
18.     while (std::getline(file, line)) {
19.         std::istringstream iss(line);
20.         int number;
21.         
22.         while (iss >> number) {
23.             frequency[number]++;
24.         }
25.     }
26.    
27.     file.close();
28.    
29.     std::cout << "文件中数字出现频率统计:" << std::endl;
30.     for (const auto& pair : frequency) {
31.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
32.     }
33.    
34.     return 0;
35. }

复制代码

高级应用

使用STL容器和算法

C++标准模板库（STL）提供了丰富的容器和算法，可以大大简化数字统计的任务。下面是一些使用STL进行数字统计的示例：

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
5. #include <numeric>
7. int main() {
8.     std::vector<int> numbers = {1, 2, 3, 4, 5, 2, 3, 2, 1, 6, 7, 8, 2};
9.    
10.     // 统计特定数字的出现次数
11.     int target = 2;
12.     int count = std::count(numbers.begin(), numbers.end(), target);
13.     std::cout << "数字 " << target << " 出现了 " << count << " 次。" << std::endl;
14.    
15.     // 计算所有数字的总和
16.     int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
17.     std::cout << "所有数字的总和是: " << sum << std::endl;
18.    
19.     // 计算数字的平均值
20.     double average = static_cast<double>(sum) / numbers.size();
21.     std::cout << "数字的平均值是: " << average << std::endl;
22.    
23.     // 找出最大值和最小值
24.     auto [minIt, maxIt] = std::minmax_element(numbers.begin(), numbers.end());
25.     std::cout << "最小值: " << *minIt << ", 最大值: " << *maxIt << std::endl;
26.    
27.     return 0;
28. }

复制代码

2. #include <iostream>
3. #include <vector>
4. #include <map>
5. #include <algorithm>
7. int main() {
8.     std::vector<int> numbers = {1, 2, 3, 4, 5, 2, 3, 2, 1, 6, 7, 8, 2};
9.     std::map<int, int> frequency;
10.    
11.     // 使用for_each和lambda表达式统计频率
12.     std::for_each(numbers.begin(), numbers.end(),
13.         [&frequency](int n) { frequency[n]++; });
14.    
15.     // 输出频率统计
16.     std::cout << "数字出现频率统计:" << std::endl;
17.     for (const auto& pair : frequency) {
18.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
19.     }
20.    
21.     // 找出出现次数最多的数字
22.     auto mostFrequent = std::max_element(frequency.begin(), frequency.end(),
23.         [](const auto& a, const auto& b) { return a.second < b.second; });
24.    
25.     std::cout << "出现次数最多的数字是 " << mostFrequent->first
26.               << "，出现了 " << mostFrequent->second << " 次。" << std::endl;
27.    
28.     return 0;
29. }

复制代码

2. #include <iostream>
3. #include <vector>
4. #include <unordered_map>
5. #include <algorithm>
7. int main() {
8.     std::vector<int> numbers = {1, 2, 3, 4, 5, 2, 3, 2, 1, 6, 7, 8, 2};
9.     std::unordered_map<int, int> frequency;
10.    
11.     // 统计频率
12.     for (int num : numbers) {
13.         frequency[num]++;
14.     }
15.    
16.     // 输出频率统计
17.     std::cout << "数字出现频率统计:" << std::endl;
18.     for (const auto& pair : frequency) {
19.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
20.     }
21.    
22.     // 按频率排序
23.     std::vector<std::pair<int, int>> sortedFrequency(frequency.begin(), frequency.end());
24.     std::sort(sortedFrequency.begin(), sortedFrequency.end(),
25.         [](const auto& a, const auto& b) { return a.second > b.second; });
26.    
27.     // 输出排序后的频率统计
28.     std::cout << "\n按频率排序后的统计:" << std::endl;
29.     for (const auto& pair : sortedFrequency) {
30.         std::cout << pair.first << ": " << pair.second << " 次" << std::endl;
31.     }
32.    
33.     return 0;
34. }

复制代码

多种数据类型的数字统计

在实际应用中，我们可能需要处理多种数据类型的数字。下面是一个示例，统计不同类型数字的出现次数：

2. #include <iostream>
3. #include <vector>
4. #include <variant>
5. #include <map>
6. #include <string>
7. #include <iomanip>
9. // 使用std::variant来处理多种数字类型
10. using NumberType = std::variant<int, float, double, long>;
12. // 访问者模式，用于打印不同类型的数字
13. struct PrintVisitor {
14.     void operator()(int i) const { std::cout << i << " (int)"; }
15.     void operator()(float f) const { std::cout << std::fixed << std::setprecision(2) << f << " (float)"; }
16.     void operator()(double d) const { std::cout << std::fixed << std::setprecision(4) << d << " (double)"; }
17.     void operator()(long l) const { std::cout << l << " (long)"; }
18. };
20. // 访问者模式，用于获取数字类型的字符串表示
21. struct TypeVisitor {
22.     std::string operator()(int) const { return "int"; }
23.     std::string operator()(float) const { return "float"; }
24.     std::string operator()(double) const { return "double"; }
25.     std::string operator()(long) const { return "long"; }
26. };
28. int main() {
29.     std::vector<NumberType> numbers = {
30.         1, 2.5f, 3.14159, 4L, 5, 6.7f, 8.90123, 10L, 11, 12.3f
31.     };
32.    
33.     // 按类型统计数字个数
34.     std::map<std::string, int> typeCount;
35.    
36.     for (const auto& num : numbers) {
37.         std::string type = std::visit(TypeVisitor{}, num);
38.         typeCount[type]++;
39.     }
40.    
41.     // 输出类型统计
42.     std::cout << "按类型统计数字个数:" << std::endl;
43.     for (const auto& pair : typeCount) {
44.         std::cout << pair.first << ": " << pair.second << " 个" << std::endl;
45.     }
46.    
47.     // 输出所有数字及其类型
48.     std::cout << "\n所有数字及其类型:" << std::endl;
49.     for (const auto& num : numbers) {
50.         std::visit(PrintVisitor{}, num);
51.         std::cout << std::endl;
52.     }
53.    
54.     return 0;
55. }

复制代码

性能优化技巧

在处理大量数据时，性能优化变得尤为重要。下面是一些优化数字统计性能的技巧：

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
5. #include <execution>
6. #include <chrono>
7. #include <random>
9. int main() {
10.     // 生成大量随机数
11.     const int size = 10000000;
12.     std::vector<int> numbers(size);
13.    
14.     std::random_device rd;
15.     std::mt19937 gen(rd());
16.     std::uniform_int_distribution<> dis(1, 100);
17.    
18.     for (int i = 0; i < size; i++) {
19.         numbers[i] = dis(gen);
20.     }
21.    
22.     // 使用顺序算法统计特定数字的出现次数
23.     int target = 42;
24.     auto start = std::chrono::high_resolution_clock::now();
25.     int countSeq = std::count(numbers.begin(), numbers.end(), target);
26.     auto end = std::chrono::high_resolution_clock::now();
27.     std::chrono::duration<double> seqTime = end - start;
28.    
29.     std::cout << "顺序算法结果: " << countSeq << std::endl;
30.     std::cout << "顺序算法耗时: " << seqTime.count() << " 秒" << std::endl;
31.    
32.     // 使用并行算法统计特定数字的出现次数
33.     start = std::chrono::high_resolution_clock::now();
34.     int countPar = std::count(std::execution::par, numbers.begin(), numbers.end(), target);
35.     end = std::chrono::high_resolution_clock::now();
36.     std::chrono::duration<double> parTime = end - start;
37.    
38.     std::cout << "并行算法结果: " << countPar << std::endl;
39.     std::cout << "并行算法耗时: " << parTime.count() << " 秒" << std::endl;
40.    
41.     std::cout << "并行算法比顺序算法快 " << (seqTime.count() / parTime.count()) << " 倍" << std::endl;
42.    
43.     return 0;
44. }

复制代码

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
5. #include <random>
7. // 使用位运算统计特定数字的出现次数
8. int countWithBitOps(const std::vector<int>& numbers, int target) {
9.     int count = 0;
10.     for (int num : numbers) {
11.         // 使用异或运算和比较，避免分支预测
12.         count += ((num ^ target) - 1) >> 31 & 1;
13.     }
14.     return count;
15. }
17. int main() {
18.     // 生成大量随机数
19.     const int size = 10000000;
20.     std::vector<int> numbers(size);
21.    
22.     std::random_device rd;
23.     std::mt19937 gen(rd());
24.     std::uniform_int_distribution<> dis(1, 100);
25.    
26.     for (int i = 0; i < size; i++) {
27.         numbers[i] = dis(gen);
28.     }
29.    
30.     int target = 42;
31.    
32.     // 使用标准算法
33.     auto start = std::chrono::high_resolution_clock::now();
34.     int countStd = std::count(numbers.begin(), numbers.end(), target);
35.     auto end = std::chrono::high_resolution_clock::now();
36.     std::chrono::duration<double> stdTime = end - start;
37.    
38.     // 使用位运算优化
39.     start = std::chrono::high_resolution_clock::now();
40.     int countBit = countWithBitOps(numbers, target);
41.     end = std::chrono::high_resolution_clock::now();
42.     std::chrono::duration<double> bitTime = end - start;
43.    
44.     std::cout << "标准算法结果: " << countStd << std::endl;
45.     std::cout << "标准算法耗时: " << stdTime.count() << " 秒" << std::endl;
46.    
47.     std::cout << "位运算算法结果: " << countBit << std::endl;
48.     std::cout << "位运算算法耗时: " << bitTime.count() << " 秒" << std::endl;
49.    
50.     std::cout << "位运算算法比标准算法快 " << (stdTime.count() / bitTime.count()) << " 倍" << std::endl;
51.    
52.     return 0;
53. }

复制代码

2. #include <iostream>
3. #include <vector>
4. #include <unordered_map>
5. #include <random>
6. #include <chrono>
8. // 使用连续内存的向量代替哈希表进行频率统计
9. std::vector<int> countWithVector(const std::vector<int>& numbers, int maxVal) {
10.     std::vector<int> frequency(maxVal + 1, 0);
11.    
12.     for (int num : numbers) {
13.         if (num >= 0 && num <= maxVal) {
14.             frequency[num]++;
15.         }
16.     }
17.    
18.     return frequency;
19. }
21. // 使用哈希表进行频率统计
22. std::unordered_map<int, int> countWithUnorderedMap(const std::vector<int>& numbers) {
23.     std::unordered_map<int, int> frequency;
24.    
25.     for (int num : numbers) {
26.         frequency[num]++;
27.     }
28.    
29.     return frequency;
30. }
32. int main() {
33.     // 生成大量随机数
34.     const int size = 10000000;
35.     std::vector<int> numbers(size);
36.    
37.     std::random_device rd;
38.     std::mt19937 gen(rd());
39.     std::uniform_int_distribution<> dis(1, 1000);
40.    
41.     for (int i = 0; i < size; i++) {
42.         numbers[i] = dis(gen);
43.     }
44.    
45.     // 使用向量进行频率统计
46.     auto start = std::chrono::high_resolution_clock::now();
47.     auto frequencyVec = countWithVector(numbers, 1000);
48.     auto end = std::chrono::high_resolution_clock::now();
49.     std::chrono::duration<double> vecTime = end - start;
50.    
51.     // 使用哈希表进行频率统计
52.     start = std::chrono::high_resolution_clock::now();
53.     auto frequencyMap = countWithUnorderedMap(numbers);
54.     end = std::chrono::high_resolution_clock::now();
55.     std::chrono::duration<double> mapTime = end - start;
56.    
57.     std::cout << "向量统计耗时: " << vecTime.count() << " 秒" << std::endl;
58.     std::cout << "哈希表统计耗时: " << mapTime.count() << " 秒" << std::endl;
59.    
60.     std::cout << "向量统计比哈希表统计快 " << (mapTime.count() / vecTime.count()) << " 倍" << std::endl;
61.    
62.     return 0;
63. }

复制代码

实际案例分析

数据分析中的数字统计

在数据分析中，我们经常需要统计各种数字指标，如平均值、中位数、众数等。下面是一个示例，展示如何使用C++进行基本的数据分析：

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
5. #include <numeric>
6. #include <map>
7. #include <iomanip>
8. #include <random>
10. class DataAnalyzer {
11. private:
12.     std::vector<double> data;
13.    
14. public:
15.     DataAnalyzer(const std::vector<double>& input) : data(input) {}
16.    
17.     // 计算平均值
18.     double mean() const {
19.         if (data.empty()) return 0.0;
20.         return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
21.     }
22.    
23.     // 计算中位数
24.     double median() {
25.         if (data.empty()) return 0.0;
26.         
27.         std::sort(data.begin(), data.end());
28.         
29.         size_t size = data.size();
30.         if (size % 2 == 0) {
31.             return (data[size/2 - 1] + data[size/2]) / 2.0;
32.         } else {
33.             return data[size/2];
34.         }
35.     }
36.    
37.     // 计算众数
38.     std::vector<double> modes() {
39.         if (data.empty()) return {};
40.         
41.         std::map<double, int> frequency;
42.         for (double value : data) {
43.             frequency[value]++;
44.         }
45.         
46.         int maxFreq = 0;
47.         for (const auto& pair : frequency) {
48.             if (pair.second > maxFreq) {
49.                 maxFreq = pair.second;
50.             }
51.         }
52.         
53.         std::vector<double> result;
54.         for (const auto& pair : frequency) {
55.             if (pair.second == maxFreq) {
56.                 result.push_back(pair.first);
57.             }
58.         }
59.         
60.         return result;
61.     }
62.    
63.     // 计算标准差
64.     double standardDeviation() const {
65.         if (data.size() < 2) return 0.0;
66.         
67.         double m = mean();
68.         double sqSum = std::inner_product(data.begin(), data.end(), data.begin(), 0.0);
69.         return std::sqrt(sqSum / data.size() - m * m);
70.     }
71.    
72.     // 计算四分位数
73.     std::vector<double> quartiles() {
74.         if (data.empty()) return {0.0, 0.0, 0.0};
75.         
76.         std::sort(data.begin(), data.end());
77.         
78.         size_t n = data.size();
79.         double q1, q2, q3;
80.         
81.         // 计算Q2（中位数）
82.         if (n % 2 == 0) {
83.             q2 = (data[n/2 - 1] + data[n/2]) / 2.0;
84.         } else {
85.             q2 = data[n/2];
86.         }
87.         
88.         // 计算Q1
89.         size_t m = n / 2;
90.         if (m % 2 == 0) {
91.             q1 = (data[m/2 - 1] + data[m/2]) / 2.0;
92.         } else {
93.             q1 = data[m/2];
94.         }
95.         
96.         // 计算Q3
97.         if (n % 2 == 0) {
98.             if (m % 2 == 0) {
99.                 q3 = (data[m + m/2 - 1] + data[m + m/2]) / 2.0;
100.             } else {
101.                 q3 = data[m + m/2];
102.             }
103.         } else {
104.             if (m % 2 == 0) {
105.                 q3 = (data[m + 1 + m/2 - 1] + data[m + 1 + m/2]) / 2.0;
106.             } else {
107.                 q3 = data[m + 1 + m/2];
108.             }
109.         }
110.         
111.         return {q1, q2, q3};
112.     }
113.    
114.     // 生成统计报告
115.     void generateReport() {
116.         std::cout << std::fixed << std::setprecision(2);
117.         std::cout << "数据统计报告:" << std::endl;
118.         std::cout << "--------------------------------" << std::endl;
119.         std::cout << "数据点数量: " << data.size() << std::endl;
120.         std::cout << "平均值: " << mean() << std::endl;
121.         std::cout << "中位数: " << median() << std::endl;
122.         
123.         auto modeValues = modes();
124.         if (modeValues.size() == 1) {
125.             std::cout << "众数: " << modeValues[0] << std::endl;
126.         } else {
127.             std::cout << "众数: ";
128.             for (size_t i = 0; i < modeValues.size(); i++) {
129.                 if (i > 0) std::cout << ", ";
130.                 std::cout << modeValues[i];
131.             }
132.             std::cout << std::endl;
133.         }
134.         
135.         std::cout << "标准差: " << standardDeviation() << std::endl;
136.         
137.         auto qs = quartiles();
138.         std::cout << "四分位数: Q1=" << qs[0] << ", Q2=" << qs[1] << ", Q3=" << qs[2] << std::endl;
139.         std::cout << "--------------------------------" << std::endl;
140.     }
141. };
143. int main() {
144.     // 生成随机数据
145.     const int size = 100;
146.     std::vector<double> data(size);
147.    
148.     std::random_device rd;
149.     std::mt19937 gen(rd());
150.     std::normal_distribution<> dist(50.0, 15.0); // 正态分布，均值50，标准差15
151.    
152.     for (int i = 0; i < size; i++) {
153.         data[i] = dist(gen);
154.     }
155.    
156.     // 创建数据分析器并生成报告
157.     DataAnalyzer analyzer(data);
158.     analyzer.generateReport();
159.    
160.     return 0;
161. }

复制代码

游戏开发中的数字统计

在游戏开发中，数字统计可以用于各种目的，如计分、统计玩家行为、分析游戏数据等。下面是一个简单的游戏统计系统示例：

2. #include <iostream>
3. #include <vector>
4. #include <map>
5. #include <string>
6. #include <algorithm>
7. #include <random>
8. #include <ctime>
10. class GameStats {
11. private:
12.     std::map<std::string, int> playerScores;
13.     std::map<int, int> levelCompletionTimes; // 关卡ID -> 完成时间（秒）
14.     std::map<std::string, int> itemUsage; // 物品名称 -> 使用次数
15.     std::vector<int> dailyActivePlayers; // 每日活跃玩家数
16.    
17. public:
18.     // 添加玩家分数
19.     void addPlayerScore(const std::string& playerName, int score) {
20.         playerScores[playerName] += score;
21.     }
22.    
23.     // 记录关卡完成时间
24.     void recordLevelCompletion(int levelId, int timeInSeconds) {
25.         levelCompletionTimes[levelId] = timeInSeconds;
26.     }
27.    
28.     // 记录物品使用
29.     void recordItemUsage(const std::string& itemName) {
30.         itemUsage[itemName]++;
31.     }
32.    
33.     // 记录每日活跃玩家数
34.     void recordDailyActivePlayers(int count) {
35.         dailyActivePlayers.push_back(count);
36.     }
37.    
38.     // 获取排行榜
39.     std::vector<std::pair<std::string, int>> getLeaderboard(int topN = 10) {
40.         std::vector<std::pair<std::string, int>> sortedPlayers(
41.             playerScores.begin(), playerScores.end());
42.         
43.         std::sort(sortedPlayers.begin(), sortedPlayers.end(),
44.             [](const auto& a, const auto& b) { return a.second > b.second; });
45.         
46.         if (sortedPlayers.size() > static_cast<size_t>(topN)) {
47.             sortedPlayers.resize(topN);
48.         }
49.         
50.         return sortedPlayers;
51.     }
52.    
53.     // 获取平均关卡完成时间
54.     double getAverageLevelCompletionTime() const {
55.         if (levelCompletionTimes.empty()) return 0.0;
56.         
57.         double sum = 0.0;
58.         for (const auto& pair : levelCompletionTimes) {
59.             sum += pair.second;
60.         }
61.         
62.         return sum / levelCompletionTimes.size();
63.     }
64.    
65.     // 获取最常用的物品
66.     std::vector<std::pair<std::string, int>> getMostUsedItems(int topN = 5) {
67.         std::vector<std::pair<std::string, int>> sortedItems(
68.             itemUsage.begin(), itemUsage.end());
69.         
70.         std::sort(sortedItems.begin(), sortedItems.end(),
71.             [](const auto& a, const auto& b) { return a.second > b.second; });
72.         
73.         if (sortedItems.size() > static_cast<size_t>(topN)) {
74.             sortedItems.resize(topN);
75.         }
76.         
77.         return sortedItems;
78.     }
79.    
80.     // 获取平均每日活跃玩家数
81.     double getAverageDailyActivePlayers() const {
82.         if (dailyActivePlayers.empty()) return 0.0;
83.         
84.         double sum = 0.0;
85.         for (int count : dailyActivePlayers) {
86.             sum += count;
87.         }
88.         
89.         return sum / dailyActivePlayers.size();
90.     }
91.    
92.     // 生成统计报告
93.     void generateReport() {
94.         std::cout << "游戏统计报告" << std::endl;
95.         std::cout << "==========================" << std::endl;
96.         
97.         // 排行榜
98.         std::cout << "\n玩家排行榜 (前5名):" << std::endl;
99.         auto leaderboard = getLeaderboard(5);
100.         for (size_t i = 0; i < leaderboard.size(); i++) {
101.             std::cout << (i+1) << ". " << leaderboard[i].first
102.                       << ": " << leaderboard[i].second << " 分" << std::endl;
103.         }
104.         
105.         // 关卡完成时间
106.         std::cout << "\n关卡统计:" << std::endl;
107.         std::cout << "平均关卡完成时间: " << getAverageLevelCompletionTime() << " 秒" << std::endl;
108.         std::cout << "总关卡数: " << levelCompletionTimes.size() << std::endl;
109.         
110.         // 物品使用
111.         std::cout << "\n最常用物品 (前3名):" << std::endl;
112.         auto topItems = getMostUsedItems(3);
113.         for (size_t i = 0; i < topItems.size(); i++) {
114.             std::cout << (i+1) << ". " << topItems[i].first
115.                       << ": " << topItems[i].second << " 次" << std::endl;
116.         }
117.         
118.         // 每日活跃玩家
119.         std::cout << "\n玩家活跃度:" << std::endl;
120.         std::cout << "平均每日活跃玩家数: " << getAverageDailyActivePlayers() << std::endl;
121.         std::cout << "记录天数: " << dailyActivePlayers.size() << std::endl;
122.         
123.         std::cout << "\n==========================" << std::endl;
124.     }
125. };
127. int main() {
128.     // 创建游戏统计对象
129.     GameStats stats;
130.    
131.     // 模拟游戏数据
132.     std::vector<std::string> playerNames = {"Alice", "Bob", "Charlie", "David", "Eve", "Frank", "Grace"};
133.     std::vector<std::string> itemNames = {"Health Potion", "Mana Potion", "Sword", "Shield", "Bow"};
134.    
135.     std::random_device rd;
136.     std::mt19937 gen(rd());
137.    
138.     // 模拟玩家分数
139.     std::uniform_int_distribution<> scoreDist(100, 1000);
140.     for (int i = 0; i < 50; i++) {
141.         std::string player = playerNames[gen() % playerNames.size()];
142.         int score = scoreDist(gen);
143.         stats.addPlayerScore(player, score);
144.     }
145.    
146.     // 模拟关卡完成时间
147.     std::uniform_int_distribution<> levelDist(1, 10);
148.     std::uniform_int_distribution<> timeDist(60, 600);
149.     for (int i = 0; i < 30; i++) {
150.         int level = levelDist(gen);
151.         int time = timeDist(gen);
152.         stats.recordLevelCompletion(level, time);
153.     }
154.    
155.     // 模拟物品使用
156.     std::uniform_int_distribution<> itemDist(0, itemNames.size() - 1);
157.     for (int i = 0; i < 100; i++) {
158.         std::string item = itemNames[itemDist(gen)];
159.         stats.recordItemUsage(item);
160.     }
161.    
162.     // 模拟每日活跃玩家
163.     std::uniform_int_distribution<> playerDist(50, 200);
164.     for (int i = 0; i < 30; i++) {
165.         int count = playerDist(gen);
166.         stats.recordDailyActivePlayers(count);
167.     }
168.    
169.     // 生成统计报告
170.     stats.generateReport();
171.    
172.     return 0;
173. }

复制代码

科学计算中的数字统计

在科学计算中，数字统计是数据分析的基础。下面是一个示例，展示如何使用C++进行科学数据的统计分析：

2. #include <iostream>
3. #include <vector>
4. #include <algorithm>
5. #include <numeric>
6. #include <cmath>
7. #include <iomanip>
8. #include <random>
10. class ScientificDataAnalyzer {
11. private:
12.     std::vector<double> data;
13.    
14. public:
15.     ScientificDataAnalyzer(const std::vector<double>& input) : data(input) {}
16.    
17.     // 基本统计量
18.     double mean() const {
19.         if (data.empty()) return 0.0;
20.         return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
21.     }
22.    
23.     double median() {
24.         if (data.empty()) return 0.0;
25.         
26.         std::sort(data.begin(), data.end());
27.         
28.         size_t size = data.size();
29.         if (size % 2 == 0) {
30.             return (data[size/2 - 1] + data[size/2]) / 2.0;
31.         } else {
32.             return data[size/2];
33.         }
34.     }
35.    
36.     double variance() const {
37.         if (data.size() < 2) return 0.0;
38.         
39.         double m = mean();
40.         double sum = 0.0;
41.         for (double value : data) {
42.             sum += (value - m) * (value - m);
43.         }
44.         
45.         return sum / (data.size() - 1); // 样本方差
46.     }
47.    
48.     double standardDeviation() const {
49.         return std::sqrt(variance());
50.     }
51.    
52.     // 偏度和峰度
53.     double skewness() const {
54.         if (data.size() < 3) return 0.0;
55.         
56.         double m = mean();
57.         double s = standardDeviation();
58.         
59.         if (s == 0.0) return 0.0;
60.         
61.         double sum = 0.0;
62.         for (double value : data) {
63.             double z = (value - m) / s;
64.             sum += z * z * z;
65.         }
66.         
67.         return sum / data.size();
68.     }
69.    
70.     double kurtosis() const {
71.         if (data.size() < 4) return 0.0;
72.         
73.         double m = mean();
74.         double s = standardDeviation();
75.         
76.         if (s == 0.0) return 0.0;
77.         
78.         double sum = 0.0;
79.         for (double value : data) {
80.             double z = (value - m) / s;
81.             sum += z * z * z * z;
82.         }
83.         
84.         return sum / data.size() - 3.0; // 超出峰度
85.     }
86.    
87.     // 百分位数
88.     double percentile(double p) {
89.         if (data.empty() || p < 0.0 || p > 100.0) return 0.0;
90.         
91.         std::sort(data.begin(), data.end());
92.         
93.         double n = data.size();
94.         double pos = p * (n - 1) / 100.0;
95.         int k = static_cast<int>(pos);
96.         double d = pos - k;
97.         
98.         if (k + 1 < static_cast<int>(n)) {
99.             return data[k] + d * (data[k + 1] - data[k]);
100.         } else {
101.             return data[k];
102.         }
103.     }
104.    
105.     // 直方图
106.     std::vector<int> histogram(int bins) {
107.         if (data.empty() || bins <= 0) return {};
108.         
109.         auto [minIt, maxIt] = std::minmax_element(data.begin(), data.end());
110.         double minVal = *minIt;
111.         double maxVal = *maxIt;
112.         
113.         if (minVal == maxVal) return std::vector<int>(bins, static_cast<int>(data.size()));
114.         
115.         double binWidth = (maxVal - minVal) / bins;
116.         std::vector<int> hist(bins, 0);
117.         
118.         for (double value : data) {
119.             int binIndex = static_cast<int>((value - minVal) / binWidth);
120.             if (binIndex >= bins) binIndex = bins - 1; // 处理最大值
121.             hist[binIndex]++;
122.         }
123.         
124.         return hist;
125.     }
126.    
127.     // 相关性
128.     double correlation(const std::vector<double>& other) const {
129.         if (data.size() != other.size() || data.empty()) return 0.0;
130.         
131.         double meanX = mean();
132.         double meanY = std::accumulate(other.begin(), other.end(), 0.0) / other.size();
133.         
134.         double numerator = 0.0;
135.         double sumSqX = 0.0;
136.         double sumSqY = 0.0;
137.         
138.         for (size_t i = 0; i < data.size(); i++) {
139.             double devX = data[i] - meanX;
140.             double devY = other[i] - meanY;
141.             
142.             numerator += devX * devY;
143.             sumSqX += devX * devX;
144.             sumSqY += devY * devY;
145.         }
146.         
147.         double denominator = std::sqrt(sumSqX * sumSqY);
148.         if (denominator == 0.0) return 0.0;
149.         
150.         return numerator / denominator;
151.     }
152.    
153.     // 生成统计报告
154.     void generateReport() {
155.         std::cout << std::fixed << std::setprecision(4);
156.         std::cout << "科学数据统计分析报告" << std::endl;
157.         std::cout << "======================================" << std::endl;
158.         std::cout << "样本数量: " << data.size() << std::endl;
159.         std::cout << "平均值: " << mean() << std::endl;
160.         std::cout << "中位数: " << median() << std::endl;
161.         std::cout << "方差: " << variance() << std::endl;
162.         std::cout << "标准差: " << standardDeviation() << std::endl;
163.         std::cout << "偏度: " << skewness() << std::endl;
164.         std::cout << "峰度: " << kurtosis() << std::endl;
165.         
166.         std::cout << "\n百分位数:" << std::endl;
167.         std::cout << "最小值: " << percentile(0) << std::endl;
168.         std::cout << "25%: " << percentile(25) << std::endl;
169.         std::cout << "50% (中位数): " << percentile(50) << std::endl;
170.         std::cout << "75%: " << percentile(75) << std::endl;
171.         std::cout << "最大值: " << percentile(100) << std::endl;
172.         
173.         // 直方图
174.         int bins = 10;
175.         auto hist = histogram(bins);
176.         std::cout << "\n直方图 (" << bins << " 个区间):" << std::endl;
177.         
178.         auto [minIt, maxIt] = std::minmax_element(data.begin(), data.end());
179.         double minVal = *minIt;
180.         double maxVal = *maxIt;
181.         double binWidth = (maxVal - minVal) / bins;
182.         
183.         int maxCount = *std::max_element(hist.begin(), hist.end());
184.         int maxStars = 50;
185.         
186.         for (int i = 0; i < bins; i++) {
187.             double lower = minVal + i * binWidth;
188.             double upper = lower + binWidth;
189.             
190.             std::cout << "[" << std::fixed << std::setprecision(2) << lower
191.                       << ", " << upper << "): ";
192.             
193.             int stars = (hist[i] * maxStars) / maxCount;
194.             for (int j = 0; j < stars; j++) {
195.                 std::cout << "*";
196.             }
197.             
198.             std::cout << " (" << hist[i] << ")" << std::endl;
199.         }
200.         
201.         std::cout << "======================================" << std::endl;
202.     }
203. };
205. int main() {
206.     // 生成测试数据 - 正态分布
207.     const int size = 1000;
208.     std::vector<double> data(size);
209.    
210.     std::random_device rd;
211.     std::mt19937 gen(rd());
212.     std::normal_distribution<> dist(100.0, 15.0);
213.    
214.     for (int i = 0; i < size; i++) {
215.         data[i] = dist(gen);
216.     }
217.    
218.     // 创建分析器并生成报告
219.     ScientificDataAnalyzer analyzer(data);
220.     analyzer.generateReport();
221.    
222.     // 测试相关性
223.     std::vector<double> data2(size);
224.     for (int i = 0; i < size; i++) {
225.         // 创建与data有线性关系的数据
226.         data2[i] = 2.0 * data[i] + 10.0 + (dist(gen) - 100.0) * 0.5;
227.     }
228.    
229.     double corr = analyzer.correlation(data2);
230.     std::cout << "\n两组数据的相关系数: " << corr << std::endl;
231.    
232.     return 0;
233. }

复制代码

总结与展望

本文从基础语法到高级应用，全面介绍了如何在C++中精确统计并高效输出数字的个数。我们学习了：

1. 基础语法：基本数据类型、输入输出流和基本计数方法。
2. 中级应用：数组、字符串和文件中的数字统计。
3. 高级应用：使用STL容器和算法、多种数据类型的数字统计以及性能优化技巧。
4. 实际案例分析：数据分析、游戏开发和科学计算中的数字统计应用。

通过这些内容，读者应该能够掌握C++中数字统计的核心技能，并能够将其应用到实际项目中。

随着C++标准的不断发展，我们有理由相信未来会有更多强大的工具和库来支持数字统计和数据分析。例如，C++20引入的范围库（Ranges）和概念（Concepts）将进一步简化数据处理的代码。此外，随着并行计算和GPU编程的普及，我们也将看到更多高效的数字统计算法的出现。

无论你是初学者还是有经验的开发者，掌握数字统计这一核心技能都将对你的编程之路产生积极影响。希望本文能够帮助你更好地理解和应用C++中的数字统计技术。