以加减法计算器为例，了解C++命名作用域与函数调用

*************

C++

topic: 命名作用域与函数调用

*************

|----------------------------------------------------------------------------|
| |

The concept is fully introducted in the last artical. Please refer to 抽象：C++命名作用域与函数调用-CSDN博客

And let's make a calculator to review the basic structure in c++.

1、全局函数

A good habit to name the global function is using global_XXX.

#include <iostream>

int global_add(int a, int b) // 全局函数的名字是global_add
{
    return a + b; // 返回a和b的和
}

2、命名空间

Like a villa, a space to name the variables.

#include <iostream>

int global_add(int a, int b) // 全局函数的名字是global_add
{
    return a + b; // 返回a和b的和
}

namespace calculate
{
    // do sth. here
}

call global function in namespace.

#include <iostream>

int global_add(int a, int b) // 全局函数的名字是global_add
{
    return a + b; // 返回a和b的和
}

namespace calculate
{
    // 调用全局函数
    int add(int a, int b) // 函数的名字是add
    {
        return global_add(a, b); // 返回全局函数的结果
    }
}

and of course you can add a function directly in namespace calculate.

#include <iostream>

// 全局加法函数
int global_add(int a, int b) 
{
    return a + b;
}

namespace calculate 
{
    // 1. 直接定义在命名空间中的加法函数（独立实现）
    int add_in_class(int a, int b) 
    {
        return a + b;  // 直接实现加法
    }
    
    // 2. 调用全局加法函数的版本（复用全局实现）
    int add_by_global(int a, int b) 
    {
        return global_add(a, b);  // 调用全局函数
    }
}

Extend add class.

#include <iostream>

// 全局加法函数
int global_add(int a, int b) 
{
    return a + b;
}

namespace calculate 
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b) 
        {
            return a + b;  // 直接实现加法
        }
        
        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b) 
        {
            return global_add(a, b);  // 调用全局函数
        }
    };
}

call the add functions in the add class is easy.

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b)
        {
            return a + b; // 直接实现加法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b)
        {
            return global_add(a, b); // 调用全局函数
        }

        // 调用加法函数
        void call_add(int a, int b)
        {
            int result1 = add_in_class(a, b); // 调用类内的加法函数
            int result2 = add_by_global(a, b); // 调用全局加法函数
        }
    };

extend suntract class

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b)
        {
            return a + b; // 直接实现加法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b)
        {
            return global_add(a, b); // 调用全局函数
        }

        // 调用加法函数
        void call_add(int a, int b)
        {
            int result1 = add_in_class(a, b); // 调用类内的加法函数
            int result2 = add_by_global(a, b); // 调用全局加法函数
        }
    };

    // 拓展减法的类
    class subtract
    {
        public:
        // 1. 直接定义在类中的减法函数（独立实现）
        int subtract_in_class(int a, int b)
        {
            return a - b; // 直接实现减法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int subtract_by_global(int a, int b)
        {
            return global_add(a, -b); // 调用全局函数
        }
    };
}

extend an auto calculating calss, so that program can do the adding and subtracting at the same time.

#include <iostream>

// 全局加法函数
int global_add(int a, int b)
{
    return a + b;
}

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b)
        {
            return a + b; // 直接实现加法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b)
        {
            return global_add(a, b); // 调用全局函数
        }

        // 调用加法函数
        void call_add(int a, int b)
        {
            int result1 = add_in_class(a, b); // 调用类内的加法函数
            int result2 = add_by_global(a, b); // 调用全局加法函数
        }
    };

    // 拓展减法的类
    class subtract
    {
        public:
        // 1. 直接定义在类中的减法函数（独立实现）
        int subtract_in_class(int a, int b)
        {
            return a - b; // 直接实现减法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int subtract_by_global(int a, int b)
        {
            return global_add(a, -b); // 调用全局函数
        }
    };

    // 执行同时调用加法和减法
    class autoCalculate
    {
        
    };

Create an object to call the function in other classes. If you want to call functions of other class, make sure to creating an object from the class which is refreed. Do have to create an object when global function is called.

#include <iostream>

// 全局加法函数
int global_add(int a, int b)
{
    return a + b;
}

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b)
        {
            return a + b; // 直接实现加法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b)
        {
            return global_add(a, b); // 调用全局函数
        }

        // 调用加法函数
        void call_add(int a, int b)
        {
            int result1 = add_in_class(a, b); // 调用类内的加法函数
            int result2 = add_by_global(a, b); // 调用全局加法函数
        }
    };

    // 拓展减法的类
    class subtract
    {
        public:
        // 1. 直接定义在类中的减法函数（独立实现）
        int subtract_in_class(int a, int b)
        {
            return a - b; // 直接实现减法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int subtract_by_global(int a, int b)
        {
            return global_add(a, -b); // 调用全局函数
        }
    };

    // 执行同时调用加法和减法
    class autoCalculate
    {
        public:

        add autoAdd; // 创建一个add类的对象autoAdd
        subtract autoSubtract; // 创建一个subtract类的对象autoSubtract

        void call_add_subtract(int a, int b)
        {
            autoAdd.add_in_class(a, b); // 调用类内的加法函数
            autoSubtract.subtract_in_class(a, b); // 调用类内的减法函数
            autoAdd.add_by_global(a, b); // 调用全局加法函数
            global_add(a, b); // 调用全局加法函数时不需要创建对象
        }
    };
}

Main code is compulsory. In the program, main code is the start of the system. All codes start from mian code.

#include <iostream>

// 全局加法函数
int global_add(int a, int b)
{
    return a + b;
}

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b)
        {
            return a + b; // 直接实现加法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b)
        {
            return global_add(a, b); // 调用全局函数
        }

        // 调用加法函数
        void call_add(int a, int b)
        {
            int result1 = add_in_class(a, b); // 调用类内的加法函数
            int result2 = add_by_global(a, b); // 调用全局加法函数
        }
    };

    // 拓展减法的类
    class subtract
    {
        public:
        // 1. 直接定义在类中的减法函数（独立实现）
        int subtract_in_class(int a, int b)
        {
            return a - b; // 直接实现减法
        }

        // 2. 调用全局加法函数的版本（复用全局实现）
        int subtract_by_global(int a, int b)
        {
            return global_add(a, -b); // 调用全局函数
        }
    };

    // 执行同时调用加法和减法
    class autoCalculate
    {
        public:

        add autoAdd; // 创建一个add类的对象autoAdd
        subtract autoSubtract; // 创建一个subtract类的对象autoSubtract

        void call_add_subtract(int a, int b)
        {
            autoAdd.add_in_class(a, b); // 调用类内的加法函数
            autoSubtract.subtract_in_class(a, b); // 调用类内的减法函数
            autoAdd.add_by_global(a, b); // 调用全局加法函数
            global_add(a, b); // 调用全局加法函数时不需要创建对象
        }
    };

    // 主函数是程序的入口，所有的程序都从这里开始执行
    int main()
    {
        int a = 13;
        int b = 38;

        global_add(a, b); // 调用全局加法函数，return 51

        // 调用calculate命名空间中的add类
        calculate::add myAdd; // 创建一个add类的对象myAdd
        myAdd.add_in_class(a, b); // 调用类内的加法函数，return 51
        myAdd.add_by_global(a, b); // 调用全局加法函数，return 51

        // 调用calculate命名空间中的subtract类
        calculate::subtract mySubtract; // 创建一个subtract类的对象mySubtract
        mySubtract.subtract_in_class(a, b); // 调用类内的减法函数，return -25
        mySubtract.subtract_by_global(a, b); // 调用全局加法函数，return -25

        // 调用calculate命名空间中的autoCalculate类
        calculate::autoCalculate myAutoCalculate; // 创建一个autoCalculate类的对象myAutoCalculate
        myAutoCalculate.call_add_subtract(a, b); // 调用类内的加法和减法函数， return 51和-25

        return 0; // 返回0表示程序正常结束
    }
}

**Head file is a good way to tear the code apart.**In the file, too much code puzzles angineer. So one file does only one thing. Head file difine the functions and variables. Source files declare the functions.

头文件 calculator.h：

#ifndef CALCULATOR_H
#define CALCULATOR_H

#include <iostream>

// 全局加法函数
int global_add(int a, int b);

namespace calculate
{
    // 定义一个类add
    class add
    {
    public:
        // 1. 直接定义在类中的加法函数（独立实现）
        int add_in_class(int a, int b);
        
        // 2. 调用全局加法函数的版本（复用全局实现）
        int add_by_global(int a, int b);
        
        // 调用加法函数
        void call_add(int a, int b);
    };
    
    // 拓展减法的类
    class subtract
    {
    public:
        // 1. 直接定义在类中的减法函数（独立实现）
        int subtract_in_class(int a, int b);
        
        // 2. 调用全局加法函数的版本（复用全局实现）
        int subtract_by_global(int a, int b);
    };
    
    // 执行同时调用加法和减法
    class autoCalculate
    {
    public:
        add autoAdd; // 创建一个add类的对象autoAdd
        subtract autoSubtract; // 创建一个subtract类的对象autoSubtract
        
        void call_add_subtract(int a, int b);
    };
}

#endif // CALCULATOR_H

源文件 calculator.cpp：

#include "calculator.h"

// 全局加法函数实现
int global_add(int a, int b)
{
    return a + b;
}

namespace calculate
{
    // add类方法实现
    int add::add_in_class(int a, int b)
    {
        return a + b;
    }
    
    int add::add_by_global(int a, int b)
    {
        return global_add(a, b);
    }
    
    void add::call_add(int a, int b)
    {
        int result1 = add_in_class(a, b);
        int result2 = add_by_global(a, b);
    }
    
    // subtract类方法实现
    int subtract::subtract_in_class(int a, int b)
    {
        return a - b;
    }
    
    int subtract::subtract_by_global(int a, int b)
    {
        return global_add(a, -b);
    }
    
    // autoCalculate类方法实现
    void autoCalculate::call_add_subtract(int a, int b)
    {
        autoAdd.add_in_class(a, b);
        autoSubtract.subtract_in_class(a, b);
        autoAdd.add_by_global(a, b);
        global_add(a, b);
    }
}

主程序 main.cpp：

#include "calculator.h"

int main()
{
    int a = 13;
    int b = 38;

    global_add(a, b); // 调用全局加法函数，return 51

    // 调用calculate命名空间中的add类
    calculate::add myAdd; // 创建一个add类的对象myAdd
    myAdd.add_in_class(a, b); // 调用类内的加法函数，return 51
    myAdd.add_by_global(a, b); // 调用全局加法函数，return 51

    // 调用calculate命名空间中的subtract类
    calculate::subtract mySubtract; // 创建一个subtract类的对象mySubtract
    mySubtract.subtract_in_class(a, b); // 调用类内的减法函数，return -25
    mySubtract.subtract_by_global(a, b); // 调用全局加法函数，return -25

    // 调用calculate命名空间中的autoCalculate类
    calculate::autoCalculate myAutoCalculate; // 创建一个autoCalculate类的对象myAutoCalculate
    myAutoCalculate.call_add_subtract(a, b); // 调用类内的加法和减法函数， return 51和-25

    return 0; // 返回0表示程序正常结束
}