gedit src/talker.cpp   

    #include "ros/ros.h"      #include "std_msgs/String.h"            #include <sstream>            /**       * This tutorial demonstrates simple sending of messages over the ROS system.       */      int main(int argc, char **argv)      {        /**         * The ros::init() function needs to see argc and argv so that it can perform         * any ROS arguments and name remapping that were provided at the command line. For programmatic         * remappings you can use a different version of init() which takes remappings         * directly, but for most command-line programs, passing argc and argv is the easiest         * way to do it.  The third argument to init() is the name of the node.         *         * You must call one of the versions of ros::init() before using any other         * part of the ROS system.         */        ros::init(argc, argv, "talker");              /**         * NodeHandle is the main access point to communications with the ROS system.         * The first NodeHandle constructed will fully initialize this node, and the last         * NodeHandle destructed will close down the node.         */        ros::NodeHandle n;              /**         * The advertise() function is how you tell ROS that you want to         * publish on a given topic name. This invokes a call to the ROS         * master node, which keeps a registry of who is publishing and who         * is subscribing. After this advertise() call is made, the master         * node will notify anyone who is trying to subscribe to this topic name,         * and they will in turn negotiate a peer-to-peer connection with this         * node.  advertise() returns a Publisher object which allows you to         * publish messages on that topic through a call to publish().  Once         * all copies of the returned Publisher object are destroyed, the topic         * will be automatically unadvertised.         *         * The second parameter to advertise() is the size of the message queue         * used for publishing messages.  If messages are published more quickly         * than we can send them, the number here specifies how many messages to         * buffer up before throwing some away.         */        ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);              ros::Rate loop_rate(10);              /**         * A count of how many messages we have sent. This is used to create         * a unique string for each message.         */        int count = 0;        while (ros::ok())        {          /**           * This is a message object. You stuff it with data, and then publish it.           */          std_msgs::String msg;                std::stringstream ss;          ss << "hello world " << count;          msg.data = ss.str();                ROS_INFO("%s", msg.data.c_str());                /**           * The publish() function is how you send messages. The parameter           * is the message object. The type of this object must agree with the type           * given as a template parameter to the advertise<>() call, as was done           * in the constructor above.           */          chatter_pub.publish(msg);                ros::spinOnce();                loop_rate.sleep();          ++count;        }                    return 0;      }  

1. chatter_pub.publish(msg);  

gedit src/listener.cpp  

 #include "ros/ros.h"      #include "std_msgs/String.h"            /**       * This tutorial demonstrates simple receipt of messages over the ROS system.       */      void chatterCallback(const std_msgs::String::ConstPtr& msg)      {        ROS_INFO("I heard: [%s]", msg->data.c_str());      }            int main(int argc, char **argv)      {        /**         * The ros::init() function needs to see argc and argv so that it can perform         * any ROS arguments and name remapping that were provided at the command line. For programmatic         * remappings you can use a different version of init() which takes remappings         * directly, but for most command-line programs, passing argc and argv is the easiest         * way to do it.  The third argument to init() is the name of the node.         *         * You must call one of the versions of ros::init() before using any other         * part of the ROS system.         */        ros::init(argc, argv, "listener");              /**         * NodeHandle is the main access point to communications with the ROS system.         * The first NodeHandle constructed will fully initialize this node, and the last         * NodeHandle destructed will close down the node.         */        ros::NodeHandle n;              /**         * The subscribe() call is how you tell ROS that you want to receive messages         * on a given topic.  This invokes a call to the ROS         * master node, which keeps a registry of who is publishing and who         * is subscribing.  Messages are passed to a callback function, here         * called chatterCallback.  subscribe() returns a Subscriber object that you         * must hold on to until you want to unsubscribe.  When all copies of the Subscriber         * object go out of scope, this callback will automatically be unsubscribed from         * this topic.         *         * The second parameter to the subscribe() function is the size of the message         * queue.  If messages are arriving faster than they are being processed, this         * is the number of messages that will be buffered up before beginning to throw         * away the oldest ones.         */        ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);              /**         * ros::spin() will enter a loop, pumping callbacks.  With this version, all         * callbacks will be called from within this thread (the main one).  ros::spin()         * will exit when Ctrl-C is pressed, or the node is shutdown by the master.         */        ros::spin();              return 0;      }  

    cmake_minimum_required(VERSION 2.8.3)      project(beginner_tutorials)            ## Find catkin and any catkin packages      find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)            ## Declare ROS messages and services      add_message_files(DIRECTORY msg FILES Num.msg)      add_service_files(DIRECTORY srv FILES AddTwoInts.srv)            ## Generate added messages and services      generate_messages(DEPENDENCIES std_msgs)            ## Declare a catkin package      catkin_package()  

1. cmake_minimum_required(VERSION 2.8.3)  
2. project(beginner_tutorials)  
3.   
4. ## Find catkin and any catkin packages  
5. find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)  
6.   
7. ## Declare ROS messages and services  
8. add_message_files(FILES Num.msg)  
9. add_service_files(FILES AddTwoInts.srv)  
10.   
11. ## Generate added messages and services  
12. generate_messages(DEPENDENCIES std_msgs)  
13.   
14. ## Declare a catkin package  
15. catkin_package()  
16.   
17. ## Build talker and listener  
18. include_directories(include ${catkin_INCLUDE_DIRS})  
19.   
20. add_executable(talker src/talker.cpp)  
21. target_link_libraries(talker ${catkin_LIBRARIES})  
22. add_dependencies(talker beginner_tutorials_generate_messages_cpp)  
23.   
24. add_executable(listener src/listener.cpp)  
25. target_link_libraries(listener ${catkin_LIBRARIES})  
26. add_dependencies(listener beginner_tutorials_generate_messages_cpp)  

1. catkin_make 

    

  在前面的两篇博客中我们用C++在ROS中创建了一个发布者和接收者，并使用catkin_make构建了新的节点，下面就需要验证一下，我们写的是否正确。
     首先运行roscore

     打开一个新的终端在里面运行talker：

cd ~/catkin_ws/devel/lib/beginner_tutorials
./talker 

     打开一个新的终端在里面运行listener：

cd ~/catkin_ws/devel/lib/beginner_tutorials./listener

 

     说明了我们的程序是正确的。