**這些普羅米修斯C++代碼裡面的雙冒号：：到底代表着什麼，有必要真正弄清楚了（基本是命名空間）很多徹底弄清楚了！

A::B   c	A是命名空間，B是命名空間A中的類    c是類B對應的執行個體化對象
A::B()	A是命名空間，B是命名空間中的一個獨立的函數，不屬于哪個類。	如ros::init()
A.B	A是一個類的執行個體化對象，B是這個對象裡面的一個屬性，或者了解為類裡面的一個變量
A.B()	A是一個類的執行個體化對象，B是這個對象裡面的一個函數
A.B.C	B是A的類裡面一個類成員變量，C是B這種類裡面的一個成員變量。	geometry_msgs::Pose pose pose.position.x 感覺似乎pose類是position類和orientation類的合集，也就是一個大消息是兩個小消息的合集，這種類叫什麼？一個類繼承了兩個類這種豈不是叫接口？不是，C++可以多重繼承。
A.B.C.D	同A.B.C	geometry_msgs::PoseStamped A A.pose.position.x
A::B().C()	A是命名空間，意思等同于A::B();A::C();	ros::Duration(3.0).sleep()	《C++ primer》247面有說
A.B::C()	::起到作用域分辨符的作用
A::B::C	A和B可能是嵌套的命名空間 還有一種情況，B是A類型裡面的枚舉類型，枚舉類型作為類的成員變量是靜态成員變量。(ROS話題消息裡面這樣寫就是這種情況！）	prometheus_msgs::ControlCommand::Move

我在C++ primer裡還看到過  A.B::C

拍自《C++ primer》549面

https://www.cnblogs.com/dishengAndziyu/p/10916298.html

拍自《C++ primer》247面

弄清了這些，再看之前tensorflow的LSTM  python寫的代碼，都感覺好多了。

============================================================================================================

我看了下雙冒号的作用無非是兩種，一種是作用域（命名空間），一種是靜态類。

拍自《C++ primer》147面

我下面這篇博文也有講，一般是命名空間。Eigen  ros  std應該都是命名空間。

很多為了防止不同類裡面有相同的函數名稱，或者成員名稱（就是變量名稱嘛，因為類裡面包含變量和函數啊，下面Eigen::Vector3d應該不是函數是變量，應該是類名稱，然後建立對象）（是的，應該基本都是命名空間，防止重名的出現，确實工程大了之後。你還調用各種庫，确實有這種風險）

下面那樣寫是在建立對象https://www.jianshu.com/p/79bc4ff1a8f8?utm_source=desktop&utm_medium=timeline

就是Eigen::Vector3d pos_drone_mocap; //無人機目前位置 (vicon)  這種寫法是在建立對象，而不是一個變量。我是說不對勁，就算是變量也是通過類來引用啊。

《ROS機器人程式設計原理與應用》這本書裡面也明确說了

https://www.cnblogs.com/kimmychul/p/3951229.html

https://blog.csdn.net/sinat_16643223/article/details/107620182

https://github.com/maxibooksiyi/Prometheus/blob/pr-experiment-TX2/Modules/control/src/px4_pos_estimator.cpp

這種我已經多次看到

https://blog.csdn.net/yxpandjay/article/details/80587916

https://www.xuebuyuan.com/2175603.html

https://blog.csdn.net/yaodaoji/article/details/107857790

https://blog.csdn.net/sn_gis/article/details/79009006

可能就是普羅米修斯代碼裡面沒有寫using namespace Eigen，是以都帶着Eigen：：

https://blog.csdn.net/guijiaqing/article/details/106235957

普羅米修斯自身代碼裡面也有這麼寫。

https://github.com/maxibooksiyi/Prometheus/blob/pr-experiment-TX2/Modules/mission/autonomous_landing/autonomous_landing_gps_new.cpp

https://blog.csdn.net/weixin_40603219/article/details/88596642

《機器人作業系統入門必備  機器人程式設計一學就會》這裡面也專門在C++基礎知識裡面說了C++中的命名空間，用了雙冒号。估計ROS中大部分的雙冒号都是命名空間。

這種用法我知道為什麼了，看來還是C++的命名空間的基礎知識沒有掌握好。

https://blog.csdn.net/sn_gis/article/details/79009006

https://www.cnblogs.com/wanghuixi/p/6887390.html

那我現在又有個疑問了，像 ROS的命名空間原本是在哪裡寫或者定義的呢。這裡用的時候直接寫ros::就可以，那它最開始是在哪裡定義好的呢。也就是它那命名空間是在哪裡聲明的。

似乎聲明是要像下面這樣聲明，可能他們在寫對應的庫的時候已經這麼寫了，比如Eigen庫寫的時候可能就已經這麼寫了這麼定義了。

https://www.runoob.com/cplusplus/cpp-namespaces.html

怪不得寫了using namespace std就沒有再寫什麼using namespace Eigen或者using namespace ros了，在我上面給出的普羅米修斯代碼裡面。

https://blog.csdn.net/sinat_16643223/article/details/107662464

真的是一點點啃透普羅米修斯的同時也一點點補充着C++和ROS。

現在再看普羅米修斯代碼裡的這些東西，應該就不會亂了。清楚是建立對象。

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

這種是不是建立對象的時候同時調用了構造函數

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

那ros::init()

ros::spin()

ros::ok()

這種該怎麼了解，這些都是ros的基礎代碼裡面用到的，當然普羅米修斯也用到了，這是直接調用一個明明空間下的函數？不應該是先調用類麼？

是以ros到底是一個作用域還是一個類名？

Eigen也有這種用法，Eigen在這裡講道理是命名空間，雙冒号後面跟了個函數。

我發現下面不就是命名空間：：函數麼，這麼用說明函數直接寫在了命名空間下面沒有寫在類下面，是不是這個意思？是以ros::init()  ros::spin()  ros::ok()這幾個函數不是寫在類裡面的，我暫時這麼了解吧。

看這篇博文  https://blog.csdn.net/sinat_16643223/article/details/114535835   

init()應該是一個單獨的函數

這種的又怎麼了解

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

這種三個的我懷疑，第一個是命名空間，第二個是類名，第三個是類中的成員變量名。為什麼可以直接這麼用，而不用建立對象？

Eigen也是有這樣用的，連着三個。

下面拍自《ROS機器人程式設計原理與應用》157面。

但我總感覺這個不是命名空間，這個普羅米修斯的消息是我們自己定義的，實際内容是那樣的，沒有看到什麼定義命名空間啊。

還是說ROS中的消息就是這麼用的？是的，和ROS中其他消息的用法一樣  https://www.jianshu.com/p/5c75c24f0fe6

我感覺他們命名空間的名稱很多時候和所在功能包名稱一樣，比如std_msgs。

prometheus_msgs::ControlCommand和 geometry_msgs::PoseStamped性質應該是一樣的
           

我感覺他們命名空間的名稱很多時候和所在功能包名稱一樣，比如std_msgs。是否一個節點或者功能包是有自己預設的命名空間的在ROS裡面？

https://www.jianshu.com/p/3ed51b015223

prometheus_msgs::ControlCommand和 geometry_msgs::PoseStamped性質應該是一樣的
           

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/common/msgs/msg/ControlCommand.msg

有一個重大發現，似乎證明了我上面的猜想

https://blog.csdn.net/cookie909/article/details/79842334

這裡也說私有名稱是用他們節點名稱作為命名空間

https://www.cnblogs.com/zjiaxing/p/5541841.html

莫非話題名稱前有個斜杠也是因為命名空間！！！！！！！！！！！

https://blog.csdn.net/lielieyu/article/details/79594734?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=1328602.58322.16151868030891917&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

libo說這本質是一個值，是命名空間下的命名空間下的一個變量，這麼了解的。嵌套的命名空間。

https://blog.csdn.net/weixin_38956024/article/details/112131277

但是上面如果了解成命名空間的嵌套，那下面這就不好了解了啊，我感覺他們本質還是一個類啊，命名空間下的一個類啊。不然怎麼建立對象呢。是不是msg檔案自動生成類？？？但是類裡面的變量為什麼不需要建立對象再去引用呢。

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

你看這些消息的用法，似乎都是一個類。

他們自定義的msg也是這麼用，可能ROS話題消息都是這麼用？包名：：消息名    對象名

https://blog.csdn.net/u013453604/article/details/72903398

https://blog.csdn.net/sinat_16643223/article/details/114537318

書上講自定義消息類型的時候也這麼說了，在《ROS機器人程式設計原理與應用》36面。

可能因為消息裡面那幾個量的值是定的，跟建立對象沒有關系，是以可以直接這麼寫？那我現在明白為什麼靜态類可以直接寫類名了，确實你不建立對象，那幾個量的值都是确定的！！！！！！我對這個了解更進一步了

下面拍自《ROS機器人開發實踐》44面

https://blog.csdn.net/weixin_40539125/article/details/84112472

https://blog.csdn.net/sinat_16643223/article/details/114539707

我在《ROS機器人程式設計原理與應用》這本書裡面也看到普羅米修斯裡面這種A::B::C這種用法了，看來普羅米修斯裡面這樣寫不是個例，可能真的大家都是這麼寫的。

看了下那幾個變量确實已經給值了

https://github.com/ros/common_msgs/blob/noetic-devel/visualization_msgs/msg/InteractiveMarkerControl.msg

我去看了下普羅米修斯的ControlCOmmand.msg對應的頭檔案裡面，那幾個給了值的量，是放在枚舉裡面。是不是因為是枚舉類型是以這麼寫？寫為A：：B：：C，我搜了下還真的是，枚舉類型作為類的成員變量的時候是靜态成員變量！！！！！！！！！！我們這種深入本質深入源碼去找才真正徹底弄清楚為什麼這麼寫，我原本是猜測它自動生成頭檔案時那些指派的變量前面自動加上typedef或者static什麼的，剛剛有這種想法是以重新開機電腦進入Ubuntu看，雖然不是那樣但确實是自動生成頭檔案改了些東西，是以用的時候隻能那麼寫！！！！！！！！

ControlCommand.h

// Generated by gencpp from file prometheus_msgs/ControlCommand.msg
// DO NOT EDIT!


#ifndef PROMETHEUS_MSGS_MESSAGE_CONTROLCOMMAND_H
#define PROMETHEUS_MSGS_MESSAGE_CONTROLCOMMAND_H


#include <string>
#include <vector>
#include <map>

#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>

#include <std_msgs/Header.h>
#include <prometheus_msgs/PositionReference.h>

namespace prometheus_msgs
{
template <class ContainerAllocator>
struct ControlCommand_
{
  typedef ControlCommand_<ContainerAllocator> Type;

  ControlCommand_()
    : header()
    , Command_ID(0)
    , source()
    , Mode(0)
    , Reference_State()  {
    }
  ControlCommand_(const ContainerAllocator& _alloc)
    : header(_alloc)
    , Command_ID(0)
    , source(_alloc)
    , Mode(0)
    , Reference_State(_alloc)  {
  (void)_alloc;
    }



   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
  _header_type header;

   typedef uint32_t _Command_ID_type;
  _Command_ID_type Command_ID;

   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _source_type;
  _source_type source;

   typedef uint8_t _Mode_type;
  _Mode_type Mode;

   typedef  ::prometheus_msgs::PositionReference_<ContainerAllocator>  _Reference_State_type;
  _Reference_State_type Reference_State;



// reducing the odds to have name collisions with Windows.h 
#if defined(_WIN32) && defined(Idle)
  #undef Idle
#endif
#if defined(_WIN32) && defined(Takeoff)
  #undef Takeoff
#endif
#if defined(_WIN32) && defined(Hold)
  #undef Hold
#endif
#if defined(_WIN32) && defined(Land)
  #undef Land
#endif
#if defined(_WIN32) && defined(Move)
  #undef Move
#endif
#if defined(_WIN32) && defined(Disarm)
  #undef Disarm
#endif
#if defined(_WIN32) && defined(User_Mode1)
  #undef User_Mode1
#endif
#if defined(_WIN32) && defined(User_Mode2)
  #undef User_Mode2
#endif

  enum {
    Idle = 0u,
    Takeoff = 1u,
    Hold = 2u,
    Land = 3u,
    Move = 4u,
    Disarm = 5u,
    User_Mode1 = 6u,
    User_Mode2 = 7u,
  };


  typedef boost::shared_ptr< ::prometheus_msgs::ControlCommand_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::prometheus_msgs::ControlCommand_<ContainerAllocator> const> ConstPtr;

}; // struct ControlCommand_

typedef ::prometheus_msgs::ControlCommand_<std::allocator<void> > ControlCommand;

typedef boost::shared_ptr< ::prometheus_msgs::ControlCommand > ControlCommandPtr;
typedef boost::shared_ptr< ::prometheus_msgs::ControlCommand const> ControlCommandConstPtr;

// constants requiring out of line definition

   

   

   

   

   

   

   

   



template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::prometheus_msgs::ControlCommand_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >::stream(s, "", v);
return s;
}


template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::prometheus_msgs::ControlCommand_<ContainerAllocator1> & lhs, const ::prometheus_msgs::ControlCommand_<ContainerAllocator2> & rhs)
{
  return lhs.header == rhs.header &&
    lhs.Command_ID == rhs.Command_ID &&
    lhs.source == rhs.source &&
    lhs.Mode == rhs.Mode &&
    lhs.Reference_State == rhs.Reference_State;
}

template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::prometheus_msgs::ControlCommand_<ContainerAllocator1> & lhs, const ::prometheus_msgs::ControlCommand_<ContainerAllocator2> & rhs)
{
  return !(lhs == rhs);
}


} // namespace prometheus_msgs

namespace ros
{
namespace message_traits
{





template <class ContainerAllocator>
struct IsFixedSize< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
  : FalseType
  { };

template <class ContainerAllocator>
struct IsFixedSize< ::prometheus_msgs::ControlCommand_<ContainerAllocator> const>
  : FalseType
  { };

template <class ContainerAllocator>
struct IsMessage< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
  : TrueType
  { };

template <class ContainerAllocator>
struct IsMessage< ::prometheus_msgs::ControlCommand_<ContainerAllocator> const>
  : TrueType
  { };

template <class ContainerAllocator>
struct HasHeader< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
  : TrueType
  { };

template <class ContainerAllocator>
struct HasHeader< ::prometheus_msgs::ControlCommand_<ContainerAllocator> const>
  : TrueType
  { };


template<class ContainerAllocator>
struct MD5Sum< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
{
  static const char* value()
  {
    return "452e60a420203d6b2f7bcba6708b37bc";
  }

  static const char* value(const ::prometheus_msgs::ControlCommand_<ContainerAllocator>&) { return value(); }
  static const uint64_t static_value1 = 0x452e60a420203d6bULL;
  static const uint64_t static_value2 = 0x2f7bcba6708b37bcULL;
};

template<class ContainerAllocator>
struct DataType< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
{
  static const char* value()
  {
    return "prometheus_msgs/ControlCommand";
  }

  static const char* value(const ::prometheus_msgs::ControlCommand_<ContainerAllocator>&) { return value(); }
};

template<class ContainerAllocator>
struct Definition< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
{
  static const char* value()
  {
    return "std_msgs/Header header\n"
"\n"
"## 控制指令的編号 防止接收到錯誤指令， 編号應該逐次遞加\n"
"uint32 Command_ID\n"
"\n"
"## 消息來源\n"
"string source\n"
"## 控制指令的模式 \n"
"uint8 Mode\n"
"# enum Mode 控制模式枚舉\n"
"uint8 Idle=0\n"
"uint8 Takeoff=1\n"
"uint8 Hold=2\n"
"uint8 Land=3\n"
"uint8 Move=4\n"
"uint8 Disarm=5\n"
"uint8 User_Mode1=6\n"
"uint8 User_Mode2=7\n"
"\n"
"## 控制參考量 \n"
"## 位置參考量：位置、速度、加速度、加加速度、加加加速度\n"
"## 角度參考量：偏航角、偏航角速度、偏航角加速度\n"
"PositionReference Reference_State\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: prometheus_msgs/PositionReference\n"
"std_msgs/Header header\n"
"\n"
"## 位置控制參考量\n"
"\n"
"## 預設為 XYZ位置追蹤模式 （sub_mode = 0）； 速度追蹤啟用時，控制器不考慮位置參考量及位置狀态回報\n"
"uint8 Move_mode\n"
"\n"
"uint8 XYZ_POS      = 0  ##0b00\n"
"uint8 XY_POS_Z_VEL = 1  ##0b01\n"
"uint8 XY_VEL_Z_POS = 2  ##0b10\n"
"uint8 XYZ_VEL = 3       ##0b11\n"
"uint8 XYZ_ACC = 4\n"
"uint8 TRAJECTORY   = 5  \n"
"\n"
"uint8 Move_frame\n"
"# 預設情況下均為ENU_FRAME,注意軌迹追蹤和XYZ_ACC一定是ENU_FRAME\n"
"uint8 ENU_FRAME  = 0\n"
"uint8 BODY_FRAME = 1\n"
"uint8 MIX_FRAME = 2 ##2020.4.6 臨時增加的模式，後期需要統一整合，該模式下，xy采用機體系控制，z采用enu系控制\n"
"\n"
"## 時刻： 用于軌迹追蹤\n"
"float32 time_from_start          ## [s]\n"
"\n"
"## 參考量：位置、速度、加速度、加加速度、加加加速度\n"
"float32[3] position_ref          ## [m]\n"
"float32[3] velocity_ref          ## [m/s]\n"
"float32[3] acceleration_ref      ## [m/s^2]\n"
"## float32[3] jerk_ref              ## [m/s^3]\n"
"## float32[3] snap_ref              ## [m/s^4]\n"
"\n"
"## 角度參考量：偏航角、偏航角速度、偏航角加速度\n"
"float32 yaw_ref                  ## [rad]\n"
"## float32 yaw_rate_ref             ## [rad/s] \n"
"## float32 yaw_acceleration_ref     ## [rad/s] \n"
;
  }

  static const char* value(const ::prometheus_msgs::ControlCommand_<ContainerAllocator>&) { return value(); }
};

} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

  template<class ContainerAllocator> struct Serializer< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
  {
    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
    {
      stream.next(m.header);
      stream.next(m.Command_ID);
      stream.next(m.source);
      stream.next(m.Mode);
      stream.next(m.Reference_State);
    }

    ROS_DECLARE_ALLINONE_SERIALIZER
  }; // struct ControlCommand_

} // namespace serialization
} // namespace ros

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::prometheus_msgs::ControlCommand_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::prometheus_msgs::ControlCommand_<ContainerAllocator>& v)
  {
    s << indent << "header: ";
    s << std::endl;
    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
    s << indent << "Command_ID: ";
    Printer<uint32_t>::stream(s, indent + "  ", v.Command_ID);
    s << indent << "source: ";
    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.source);
    s << indent << "Mode: ";
    Printer<uint8_t>::stream(s, indent + "  ", v.Mode);
    s << indent << "Reference_State: ";
    s << std::endl;
    Printer< ::prometheus_msgs::PositionReference_<ContainerAllocator> >::stream(s, indent + "  ", v.Reference_State);
  }
};

} // namespace message_operations
} // namespace ros

#endif // PROMETHEUS_MSGS_MESSAGE_CONTROLCOMMAND_H
           

https://blog.csdn.net/bbjjqq/article/details/6079289

那麼現在應該是可以真正非常徹底地啃透普羅米修斯裡面比如 px4_pos_estimate.cpp的代碼了。

我希望你去啃Tensorflow的代碼也像這樣去啃。

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/control/src/px4_sender.cpp

上面那個那樣寫确實就是命名空間下一個獨立的函數，沒有被類包含的，看來我的推測是對的。我在普羅米修斯代碼裡面找了下，确實就是這樣。是以可以推測 ros::init()  ros::ok()  ros::spin()這種應該也是同樣的情況！！！！！！！！！

《ROS機器人開發實踐》裡面有寫ROS中的命名空間

總結好了之後，再去看opencv的代碼都會好得多。

現在可以完全确定引用（我知建立執行個體化對象的時候，不是那種靜态值直接用的，當然靜态值直接用最前面那個也是命名空間，那就都一樣吧，都是命名空間）ROS話題消息：：最前面那個就是命名空間！！！！！

https://blog.csdn.net/sinat_16643223/article/details/114730336

是以以後再看到雙冒号，最前面那個就是命名空間！！！！！幾乎不用猶豫什麼。

那分析一下這種情況怎麼了解。

現在來分析一下這種情況，結合這篇博文： https://blog.csdn.net/sinat_16643223/article/details/114730336

講道理一個消息就是一種類，你包含了其他的消息就是包含了其他的類啊，

是以你看pose這個消息的頭檔案裡面是include了的poin和quaternion這兩個消息的頭檔案的

上面寫的struct似乎也是定義類的。

這應該就是一個函數。這應該是多重繼承的寫法

http://m.biancheng.net/view/2277.html

這也應該是繼承的寫法。

我想起java是不能多重繼承的，得用接口，是不是C++可以多重繼承。

而且我剛剛發現上面正是多重繼承下的構造函數！！！！！Pose_()正是構造函數！！！！！

http://m.biancheng.net/view/2277.html

是以ROS裡面一個消息類型是由其他小消息類型組合而成的，在C++層面上是通過多重繼承實作的。

那這種A.B.C的寫法是不是屬于子類調用或者通路父類成員變量，B是父類。

我現在有點懷疑是不是結構體嵌套。雖然C++中結構體和類沒那麼大區分，但是通過結構體嵌套的概念比較好解釋，不然為什麼它不寫成類？當然我再C++ primer裡面也看到有類嵌套。

https://blog.csdn.net/sinat_16643223/article/details/114765223

https://www.cnblogs.com/lanhaicode/p/10312032.html

https://blog.csdn.net/JoeBlackzqq/article/details/7098329

那這種寫法其實就是說Pose_這個結構體繼承了 Message這個結構體，按照上面的，繼承結構體時也是寫的Public！！！

https://blog.csdn.net/sinat_16643223/article/details/114730336

或許關鍵是這兩句，相當于一個類裡面有兩個其他類成員變量。這算不算嵌套類?是啊，一個類裡面的成員變量就是一個類的執行個體化對象，這種情況怎麼弄。這應該是很常見的情況啊是不是。這不是嵌套類，嵌套類是一個類定義在另一個類的内部（《C++ primer》746面），這不是，這應該就是普通的情況。

似乎叫類類型，《C++ primer》有說到類類型，這種是不是就叫類類型，類裡面有個類類型成員？甚至類類型成員裡面還有類類型成員，這麼一層層包着。

https://blog.csdn.net/shengwenj/article/details/49337223

我們可以再來驗證一下，這種是不是也是類中有類成員。

可以看到這個Command_Now也是一個話題消息類型的執行個體化對象。

你看，在ContrilCommand.msg裡面它就直接寫了一個

PositionReference Reference_State
           

就是一個類類型的成員變量不是！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/common/msgs/msg/ControlCommand.msg

https://gitee.com/maxibooksiyi/Prometheus/blob/master/Modules/common/msgs/msg/PositionReference.msg

也怪不得PoseStamped話題消息類型定義裡面就兩句話，我一開始還以為是不是弄錯了，現在覺得沒有，就是兩個類類型成員變量！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！那這樣我的了解是對的。

https://github.com/ros/common_msgs/blob/noetic-devel/geometry_msgs/msg/PoseStamped.msg

那麼現在看這個也應該好了解了，為什麼是A.B.C.D對吧，這麼多點。

拍自《ROS機器人程式設計原理與應用》330面

https://blog.csdn.net/sinat_16643223/article/details/114542703