对mindspore\ccsrc\pipeline\jit\parse\resolve.h的部分注释和对using namespace std的学习理对mindspore\ccsrc\pipeline\jit\parse\resolve.h的部分注释和using namespace std的学习理解

知识浅薄，还有许多未理解之处，欢迎各位纠正、讨论。

相对路径：mindspore\ccsrc\pipeline\jit\parse\resolve.h

C++命名空间（using namespace std） 、

        namespace，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。namespace是为了解决C++中的名字冲突而引入的。 C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。 由于namespace的概念，使用C++标准程序库的任何标识符时，可以有三种选择：

1. 直接指定标识符：例如std::iostream而不是iostream。完整语句如下：

   std::cout << std::hex << 3.4 << std::endl;

2. 使用using关键字

3. using std::cout; using std::endl; using std::cin; 以上程序可以写成如下代码：

   using std::cout <<using std::hex << 3.4 <<using std:: endl;
   
   

4. 使用using namespace std例如

   #include<iostream>
   #include<sstream>
   #include<string>
   using namespace std;

         这样命名空间std内定义的所有标识符都有效（曝光）。就好像它们被声明为全局变量一样。那么以上语句可以如下写:

cout << hex<< 3.4<< endl;

        因为标准库非常的庞大，所程序员在选择的类的名称或函数名时就很有可能和标准库中的某个名字相同。所以为了避免这种情况所造成的名字冲突，就把标准库中的一切都被放在名字空间std中。但这又会带来了一个新问题。无数原有的C++代码都依赖于使用了多年的伪标准库中的功能，他们都是在全局空间下的。所以就有了<iostream.h>和等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加”.h”实际上就是告诉编译器，你类型是什么，在哪能找到。常用的是using namespace std,就是说用C＋＋的标准名字空间。 你也可以引用你自己的名字空间。

using在C plusplus中的使用。

         1、引入命名空间 引入命名空间std的意思，这样在这个引入命名空间的范围内，使用函数时就不用再标明其出处，可以理解为告诉编译器，我从哪里来，你就到这个地方找我吧。这样就不会在调用多个同名函数的时候搞错了，A和B空间下的函数是不一样的，using A就去A下找吧，别犯错误迷路了去B下找这就错了。

         2、类型别名 在C++11新标准中，采用using来给类型取一个别名，这样就好记了，避免有的名字过于繁琐在用的时候还要写原名。

         3、在子类中引入基类的成员 继承构造 假如子类中有和基类同名的函数，这时还想用基类的函数，就可以使用using，不然就会隐藏基类的函数。

//在头文件中使用#ifdef和＃ifndef是非常重要的，可以防止双重定义的错误
#ifndef MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_RESOLVE_H_
#define MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_RESOLVE_H_//预编译命令
//用的多的函数放在.h头文件中定义声明。
//尽量不要在.h头文件中设置全局变量，或者静态全局变量。
//导入系统文件或者是自定义文件：
#include <memory>
#include <string>
#include "ir/anf.h"
#include "ir/manager.h"
#include "pipeline/jit/parse/python_adapter.h"
#include "pipeline/jit/parse/parse_base.h"
#include "abstract/abstract_value.h"
#include "utils/log_adapter.h"
// forward declaration of ResourceBase
//资源库的正向声明
namespace mindspore {//命名创建一个名为mindspore的空间，并在其中嵌套一个名为pipeline(管道)的空间
namespace pipeline {//namespace，是指标识符的各种可见范围。
class ResourceBase;//资源库Ptr
using ResourceBasePtr = std::shared_ptr<ResourceBase>;//引入使用这个空间
}  // namespace pipeline
}  // namespace mindspore
namespace mindspore {
namespace parse {
// NameSpace class for resolving python code.
//用于解析python代码的命名空间类。
class NameSpace : public Named {
 public:
  NameSpace(const std::string &module, const py::object &obj) : Named(module), module_(module), obj_(obj) {}
  ~NameSpace() override = default;//将override赋为default 表示默认存在构造函数
  MS_DECLARE_PARENT(NameSpace, Named);//对NameSpace, Named声明父项
  py::object obj() { return obj_; }//获取目标对象
  std::string module() { return module_; }//获取字符模块
  abstract::AbstractBasePtr ToAbstract() override {
    return std::make_shared<abstract::AbstractScalar>(shared_from_base<NameSpace>(), std::make_shared<External>());
  }
 private://修饰成员变量和成员 被private修饰的成员只能在本类中访问。
  // namespace of the module
  //模块的命名空间
  std::string module_;
  // namespace object
  //名称空间对象
  py::object obj_;
};
using NameSpacePtr = std::shared_ptr<NameSpace>;//引入使用NameSpace空间
// Symbol in NameSpace or Class which shall be resolved.
//名称空间或类中应解析的符号。
class Symbol : public Named {
 public:
  explicit Symbol(const std::string &symbol) : Named(symbol), symbol_(symbol) {}
  explicit Symbol(const std::string &symbol, const std::string &name) : Named(name), symbol_(symbol) {}
  ~Symbol() override = default;//表示默认存在构造函数
  MS_DECLARE_PARENT(Symbol, Named);//MS声明Symbol,和Named的父项关系
  std::string symbol() { return symbol_; }
  abstract::AbstractBasePtr ToAbstract() override {
    return std::make_shared<abstract::AbstractScalar>(shared_from_base<Symbol>(), std::make_shared<External>());
  }
 private://修饰成员变量和成员 被private修饰的成员只能在本类中访问。
  std::string symbol_;//字符串符号
};
using SymbolPtr = std::shared_ptr<Symbol>;//引入使用这个Symbol空间
// PyObjectWrapper class wrappers resolved python object for further processing.\
//Py对象包装器类包装器解析python对象以供进一步处理。
class PyObjectWrapper : public Named {//Py对象包装器
 public:
  explicit PyObjectWrapper(const py::object &obj, const std::string &name = "Python object") : Named(name), obj_(obj) {}
  ~PyObjectWrapper() override = default;//将override赋值为default 表示默认存在构造函数
  MS_DECLARE_PARENT(PyObjectWrapper, Named);//MS声明PyObjectWrapper,和Named的父项关系
  py::object obj() { return obj_; }//返回目标对象
 private://修饰成员变量和成员 被private修饰的成员只能在本类中访问。
  // the object that needs to be resolved
  //需要解决的对象
  py::object obj_;
};
// ClassObject class wrappers dataclass
//类对象类包装器数据类
class ClassObject : public PyObjectWrapper {//对象类包装器
 public:
  explicit ClassObject(const py::object &obj, const std::string &name = "Python dataclass")
      : PyObjectWrapper(obj, name) {}
  ~ClassObject() override = default;//将override赋为default 表示默认存在构造函数
  MS_DECLARE_PARENT(ClassObject, PyObjectWrapper);//MS声明父项关系ClassObject,和PyObjectWrapper
  abstract::AbstractBasePtr ToAbstract() override;//修饰类和方法
  /*1，abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
   2，abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。
  */
};
// ClassType class wrappers class name in python
//类类型类包装器python中的类名
class ClassType : public PyObjectWrapper {//类型类包装器
 public:
  explicit ClassType(const py::object &obj, const std::string &name = "Python class type")
      : PyObjectWrapper(obj, name) {}
  ~ClassType() override = default;//将override赋为default 表示默认存在构造函数
  MS_DECLARE_PARENT(ClassType, PyObjectWrapper);//MS声明父项Classtype，PyObjectWrapper
  abstract::AbstractBasePtr ToAbstract() override;
};
using ClassTypePtr = std::shared_ptr<ClassType>;//引入ClassType命名空间
// SymbolResolver class for resolving symbol extracted from AnfNode.
//用于解析从节点提取的符号的符号解析器类。
class SymbolResolver {//解析符号
 public:
  SymbolResolver(const NameSpacePtr &name_space, const SymbolPtr &symbol, const AnfNodePtr &node)
      : namespace_(name_space), symbol_(symbol), resolved_node_(node) {}
  ~SymbolResolver() = default;//将SymbolResolver赋为default 表示默认存在构造函数
  // resolve symbol in namespace and save it in result_;
  //解析命名空间中的符号并将其保存在结果中
  bool Resolve();//判断是否（bool）完成解析
  NameSpacePtr get_namespace() { return namespace_; }
  //获取命名空间
  SymbolPtr symbol() { return symbol_; }
  //获取符号标记
  py::object &result() { return result_; }
  //目标结果
  AnfNodePtr resolved_node() { return resolved_node_; }
  //解析节点
  // Resolve result
  //解析结果
  py::object result_;
 private:
  // namespace where the symbol locates
  //符号所在的命名空间
  NameSpacePtr namespace_;
  // the symbol that needs to be resovled
  //需要解决的符号
  SymbolPtr symbol_;
  // the node that has been resolved
  //已解析的节点
  AnfNodePtr resolved_node_;
};
using SymbolResolverPtr = std::shared_ptr<SymbolResolver>;
// Resolve symbol in namespace.
//解析命名空间中的符号
AnfNodePtr ResolveSymbol(const FuncGraphManagerPtr &manager, const NameSpacePtr &name_space, const SymbolPtr &symbol,
                         const AnfNodePtr &node);
// Resolve Cell with attr name.
//解析具有attr名称的单元格。
AnfNodePtr ResolveCellwithAttr(const FuncGraphManagerPtr &manager, const NameSpacePtr &name_space,
                               const SymbolPtr &symbol, const AnfNodePtr &node, const std::string &attr);
// Resolve one graph which normally is the root graph. FuncGraph shall be managed by res->manager().
//解析一个通常为根图的图。FuncGraph应由res管理器管理
bool ResolveFuncGraph(const FuncGraphPtr &func_graph, const pipeline::ResourceBasePtr &res, bool use_profile = true);
// Resolve all graphs in manager which is defined outside of pipeline::Resource.
// Mainly used for test cases or resolve graphs which will not be managed by manager.
//解析在pipeline:：Resource之外定义的管理器中的所有图形。
//主要用于不由manager管理的测试用例或解析图。
bool ResolveAll(const FuncGraphManagerPtr &manager);//判断是否（bool类型）解析所有函数图管理器
}  // namespace parse
}  // namespace mindspore
#endif  // MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_RESOLVE_H_

以上即为本篇的所有内容，因学识与能力有限，如有不足之处，请多多包涵与指教。 学习的博客：https://blog.csdn.net/fsz520w/article/details/82561795