*************
C++
topic：结构
*************
Structure is a very intersting issue. I really don't like concepts as it is boring. I would like to cases instead. If I want to learn something, donot hesitate to make shits.
Like building a house. When I was at school my dream is to bought a flat in the very top of the building. I stand by the big floor-to-ceiling window watching outside, colourful and busy. The traffic flows and shining neon are the breathes of the city. It has no relation with the structure of the code so forget it. When building the house, structure always comes significant.
Then add some elements and it will superise you.
So I will do some shit first. Here is the beginning of the caculator.
#include <iostream> // 包含输入输出流库
int main()
{
// 主函数，程序的起点
return 0; // 程序正常结束
}So think about the work flow, which is the structure of the code.
- 提示用户输入两个整数。
- 读取用户输入，并检查输入是否有效。
- 如果输入无效，给出错误提示。
- 计算加法和减法的结果。
- 输出结果。
And the first thing is input twonumbers:
#include <iostream>
int main()
{
"请输入第一个整数: ";
"请输入第二个整数: ";
return 0;
}
Introduce the new friend, namespace. Pay special attention to the line here. Every time the line comes first, a new friend comes second.
namespace 就是 避免命名冲突，举个例子，我叫“ElseWhereR”，在‘学校’这个命名空间，ElseWhereR是校草。在‘公司’这个命名空间中，ElseWhereR是董事长。ElseWhereR是同一个人，但是在不同的命名空间中可以独立，不会互相干扰。
我写的第一个程序，hello world：
#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
} |
But， 我在抄这段代码的时候， std:: 这个我要经常写，非常的繁琐。这个时候就要介绍 namespace这个非常友好的朋友了。这个的作用就是告诉程序，我要自己起名字了。这个的用法如下：
using namespace xjbName;如果将这项黑科技用在代码中， 在 C++ 中，标准库的所有符号（如 cout、cin 等）都包含在 std 命名空间中。但是值得注意的是，namespace的名字是可以随便取的， using 也是可以省略的。
#include <iostream>
using namespace std;
int main() {
cout << "Hello, World!" << endl;
return 0;
}经常写代码的都知道，需要告诉计算机数字的类型，这里直接 int，整数的意思：
#include <iostream>
int main() {
int num1, num2;
std::cout << "请输入第一个整数: ";
std::cin >> num1;
std::cout << "请输入第二个整数: ";
std::cin >> num2;
int sum = num1 + num2;
int difference = num1 - num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
return 0;
}std::cout <<
std::cin >>
标准用法，完整意思是：
standard:: control output <<
standard:: control intput >>
两个冒号代表，cout属于std里面的一个成员。
注意，开始实战。
将命名空间和主函数分开。这个是一个很好的习惯。
- 命名空间内代码：可以将具体的功能实现和数据定义组织在一起，方便维护和优化相关功能。
- 主函数：保持简洁，只负责程序的启动和核心流程控制，使得代码结构清晰。
进一步保持代码的优雅，可以将命名空间中的代码实现方法分离出来。
命名空间只定义变量的类型：
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义两个整数变量
int num1, num2;
}接下来，写一个函数，实现求和、求差的实现方法：
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义两个整数变量
int num1, num2;
}
// 在命名空间外实现函数 calculate
void calculate()
{
int sum = JiSuanQi::num1 + JiSuanQi::num2;
int difference = JiSuanQi::num1 - JiSuanQi::num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
}
这里，void是固定格式，表示不返回任何东西，只是执行一些操作。
最后，写出主程序。
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义两个整数变量
int num1, num2;
}
// 在命名空间外实现函数 calculate
void calculate()
{
int sum = JiSuanQi::num1 + JiSuanQi::num2;
int difference = JiSuanQi::num1 - JiSuanQi::num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
}
// 主函数
int main()
{
using namespace JiSuanQi;
std::cout << "请输入第一个整数: ";
std::cin >> num1;
std::cout << "请输入第二个整数: ";
std::cin >> num2;
calculate();
return 0;
}最后输出的结果是：
 |
还有一个好玩的，如果另一个程序也想使用加减法，但是他不想再写一遍函数，那么就需要使用 类。既然外部文件想使用这个方法，那么就得定义这个构造函数为 public。
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
public:
int num1; // 第一个整数
int num2; // 第二个整数
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate() const
{
int sum = num1 + num2;
int difference = num1 - num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
}
};
}值得注意的是，构造函数的名字，和类的名字得保持一致。如果不一致，会发生编译错误。
这里的一个语法知识，用来初始化：
Calculator(int a, int b)：这是一个 构造函数，其作用是初始化类Calculator的对象。- 参数列表
(int a, int b)表示该构造函数接受两个整数参数a和b。
: num1(a), num2(b)：这是 初始化列表，用于在创建对象时初始化类的成员变量。num1(a)表示将成员变量num1的值初始化为参数a。num2(b)表示将成员变量num2的值初始化为参数b。
{}：表示构造函数的函数体。在这个例子中，函数体为空，因为所有的初始化工作都已经在初始化列表中完成。即使为空，花括号也不能省略。
如果你只希望别的程序调用你的计算，你想把num1和num2保护起来，那就加一个 private。
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
private:
int num1; // 第一个整数
int num2; // 第二个整数
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate() const
{
int sum = num1 + num2;
int difference = num1 - num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
}
};
}主函数只要进行一点点改变就OK：
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
private:
int num1; // 第一个整数
int num2; // 第二个整数
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate() const
{
int sum = num1 + num2;
int difference = num1 - num2;
std::cout << "加法结果: " << sum << std::endl;
std::cout << "减法结果: " << difference << std::endl;
}
};
}
// 主函数
int main()
{
int num1, num2;
std::cout << "请输入第一个整数: ";
std::cin >> num1;
std::cout << "请输入第二个整数: ";
std::cin >> num2;
// 使用命名空间 JiSuanQi 中的 Calculator 类
JiSuanQi::Calculator calc(num1, num2);
calc.calculate();
return 0;
}在实际的工作中，类只进行计算，职责单一化。
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate()
{
sum = num1 + num2;
difference = num1 - num2;
}
}那么，怎么获取计算结果呢？
int getSum() { return sum; }-
int getSum()：-
这是一个成员函数声明。
-
返回类型是
int，表示该函数返回一个整数值。 -
函数名是
getSum，表示该函数用于获取某个值。
-
-
{ return sum; }：-
函数体。
-
表示该函数的实现是直接返回成员变量
sum的值。
-
老鸟程序员会使用 constant，这个是固定搭配，记住只引用不改变：
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate()
{
sum = num1 + num2;
difference = num1 - num2;
}
// 获取计算结果
int getSum() const { return sum; }
int getDifference() const { return difference; }
private:
int num1; // 第一个整数
int num2; // 第二个整数
int sum; // 加法结果
int difference; // 减法结果
};
}主函数需要 使用命名空间 JiSuanQi 中的 Calculator 类。注意，主函数在使用类中的构造函数的时候，需要对构造函数声明一个对象。具体的在 函数 中有讲到。
C++ 函数-CSDN博客
#include <iostream>
// 定义命名空间 JiSuanQi
namespace JiSuanQi
{
// 定义类 Calculator
class Calculator
{
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate()
{
sum = num1 + num2;
difference = num1 - num2;
}
// 获取计算结果
int getSum() const { return sum; }
int getDifference() const { return difference; }
private:
int num1; // 第一个整数
int num2; // 第二个整数
int sum; // 加法结果
int difference; // 减法结果
};
}
// 主函数
int main()
{
int num1, num2;
std::cout << "请输入第一个整数: ";
std::cin >> num1;
std::cout << "请输入第二个整数: ";
std::cin >> num2;
// 使用命名空间 JiSuanQi 中的 Calculator 类
JiSuanQi::Calculator calc(num1, num2);
calc.calculate();
// 在类外部输出结果
std::cout << "加法结果: " << calc.getSum() << std::endl;
std::cout << "减法结果: " << calc.getDifference() << std::endl;
return 0;
}对象调用构造函数，只需要加个 . 就OK。
calc.calculate();一般来说，在一个项目中，将 类的定义 和 类的实现 放在同一份文件中，也就是 头文件。
我将类的定义和类的实现保存为 Calculator.h 文件：
#ifndef CALCULATOR_H
#define CALCULATOR_H
#include <iostream>
namespace JiSuanQi {
class Calculator {
public:
// 构造函数
Calculator(int a, int b) : num1(a), num2(b) {}
// 计算加法和减法
void calculate() {
sum = num1 + num2;
difference = num1 - num2;
}
// 获取计算结果
int getSum() const { return sum; }
int getDifference() const { return difference; }
private:
int num1; // 第一个整数
int num2; // 第二个整数
int sum; // 加法结果
int difference; // 减法结果
};
}
#endif // CALCULATOR_H那么这个天才的计算逻辑如果斯嘉丽也想使用，那么她在写代码的时候，只需要加上一句话：
#include "Calculator.h"
int main() {
int num1, num2;
std::cout << "请输入第一个整数: ";
std::cin >> num1;
std::cout << "请输入第二个整数: ";
std::cin >> num2;
// 创建 Calculator 对象并调用方法
JiSuanQi::Calculator calc(num1, num2);
calc.calculate();
// 输出结果
std::cout << "加法结果: " << calc.getSum() << std::endl;
std::cout << "减法结果: " << calc.getDifference() << std::endl;
return 0;
}很棒，我大概理解C++的逻辑了。
新年快乐。