2. 程式人生 > >ros 工作空間的覆蓋、c++程式設計介面實現通訊方式、自定義訊息格式、分散式多機通訊

ros 工作空間的覆蓋、c++程式設計介面實現通訊方式、自定義訊息格式、分散式多機通訊

阿新 • • 發佈：2018-12-11

工作空間的覆蓋

同一個工作空間下，不允許出現同名的功能包，否則無法編譯。不同工作空間下，允許出現同名的功能包，但會出現工作空間覆蓋的現象。

ros工作空間的路徑記錄在ROS_PACKAGE_PATH環境變數中，可以通過env命令檢視計算機中的環境變數，再利用管道過濾出有關ros的環境變數。

env | grep ros

新新增的工作空間路徑會自動放置在ROS_PACKAGE_PATH環境變數最前端。ros執行時，會按照順序從前往後查詢工作空間中是否存在指定的功能包。一旦找到指定的功能包就不再查詢後面的工作空間。因此，如果我們的系統當中存在名稱相同的功能包，就會出現工作空間向後覆蓋的問題。當我們使用rospack find命令查詢功能包的時候，只能查詢到最新路徑下的同名功能包，而一旦有第三方功能包依賴於原來的同名功能包，就有可能會出現問題。

通訊方式的c++實現

話題

釋出者實現步驟大致如下：

1、初始化ROS節點

2、向ROS Master註冊節點資訊，包括髮布的話題名，訊息型別

3、設定一定的頻率迴圈釋出訊息

#include <sstream>
#include "ros/ros.h"
#include "std_msgs/String.h"

int main(int argc,char **argv)
{
    ros::init(argc,argv,"talker"); //ROS節點的初始化，指定節點名稱為talker
    ros::NodeHandle n; //建立節點控制代碼
    ros::Publisher pub=n.advertise<std_msgs::String>("greet",1000); 
    //建立一個釋出者pub，指定訊息型別為std_msgs::String，話題名稱為greet，1000為快取佇列的長度
    ros::Rate loop_rate(10); //設定迴圈的頻率
    int count=0;
    while(ros::ok())
    {
        std_msgs::String msg; //建立訊息物件
        std::stringstream ss;
        ss<<"hello world"<<count;
        msg.data=ss.str(); //初始化訊息
        ROS_INFO("%s",msg.data.c_str());
        pub.publish(msg); //釋出訊息
        ros::spinOnce(); //等待訊息呼叫一次回撥函式
        loop_rate.sleep(); //按照迴圈頻率休眠
        ++count;
    }

    return 0;
}

訂閱者實現步驟大致如下：

1、初始化ROS節點

2、向ROS Master註冊節點資訊，包括訂閱的話題名，回撥函式

3、迴圈等待話題訊息，接收到訊息後進入回撥函式

4、在回撥函式中處理訊息

#include "ros/ros.h"
#include "std_msgs/String.h"

void greetCallback(const std_msgs::String::ConstPtr& msg)
// 接收到訂閱的訊息後，會進入訊息回撥函式
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());// 將接收到的訊息打印出來
}

int main(int argc, char **argv)
{
  ros::init(argc, argv, "listener");// 初始化ROS節點
  ros::NodeHandle n;// 建立節點控制代碼
  ros::Subscriber sub = n.subscribe("greet", 1000, greetCallback);
  // 建立一個Subscriber，訂閱名為greet的topic，註冊回撥函式greetCallback
  ros::spin();// 迴圈等待訊息呼叫回撥函式
  return 0;
}

修改CMakeLists檔案

1）、設定要編譯的檔案

 add_executable(${PROJECT_NAME}_node src/a_node.cpp)

其中，${PROJECT_NAME}_node 代表節點名稱，a_node.cpp 表示對應的c++檔案，修改這兩個引數即可。當然有時候一個節點可能對應著多個c++檔案，這種情況需要把所有需要的檔名都列出來。

add_executable(talker src/talker.cpp)
add_executable(listener src/talker.cpp)

2）、設定連結庫

 target_link_libraries(${PROJECT_NAME}_node    ${catkin_LIBRARIES}  )

其中，${PROJECT_NAME}_node 表示節點名稱，這裡只需要修改這一個引數即可，因為沒有使用第三方的連結庫。${catkin_LIBRARIES} 代表的是預設的ros catkin連結庫，如果我們用到了第三方庫的時候可以將第三方庫的名稱放到預設庫後面即可。

target_link_libraries(talker    ${catkin_LIBRARIES}  )
target_link_libraries(listener    ${catkin_LIBRARIES}  )

3）、設定依賴

add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS} )

其中，${PROJECT_NAME}_node  表示節點名稱，${${PROJECT_NAME}_EXPORTED_TARGETS} 表示在本package中依賴的訊息，${catkin_EXPORTED_TARGETS} 表示對其他package訊息的依賴。

當使用自定義的message、service、action時注意新增。這裡的例子當中並沒有使用自定義的訊息，所以不用新增依賴。

編譯功能包

回到工作空間，執行catkin_make對功能包進行編譯。編譯完成後即可生成talker和listener兩個可執行檔案，設定好工作空間的環境變數之後就可以通過rosrun來運行了，效果如下：

[email protected]:~$ rosrun a talker
[ INFO] [1537440776.481837500]: hello world0
[ INFO] [1537440776.582547600]: hello world1
[ INFO] [1537440776.682226900]: hello world2
[ INFO] [1537440776.781844500]: hello world3
[ INFO] [1537440776.882372400]: hello world4
[ INFO] [1537440776.982076300]: hello world5
[ INFO] [1537440777.082023100]: hello world6
[ INFO] [1537440777.181946400]: hello world7
[ INFO] [1537440777.283714400]: hello world8
[email protected]:~$ rosrun a listener
[ INFO] [1537440803.599349400]: hello world0
[ INFO] [1537440803.700052700]: hello world1
[ INFO] [1537440803.799371600]: hello world2
[ INFO] [1537440803.899708500]: hello world3
[ INFO] [1537440803.999728600]: hello world4
[ INFO] [1537440804.099783500]: hello world5
[ INFO] [1537440804.199640000]: hello world6
[ INFO] [1537440804.299546000]: hello world7
[ INFO] [1537440804.399672300]: hello world8

自定義話題訊息

1）、定義 .msg 檔案

話題訊息的定義格式：

定義一個變數列表即可，類似於c語言結構體。定義變數：資料型別+變數名 eg：我們自定義一個學生基本資訊的訊息stu.msg

如上圖，自定義訊息格式中還可以定義符號常量，類似於c語言中的define。即male代表1，female代表2，可以直接將這兩個符號常量賦給sex。

2）、修改package.xml檔案，新增功能包依賴

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

indigo之前的ros版本需要將exec_depend改成run_depend。

3）、修改CMakeLists.txt檔案，新增編譯選項

find_package(...... message_generation) #生成自定義的訊息需要使用message_generation功能包

catkin_package(CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime) #新增編譯依賴message_runtime

add_message_files(FILES Person.msg) #新增訊息檔案
generate_messages(DEPENDENCIES  std_msgs) #新增生成依賴

經過以上三個步驟，我們就可以使用catkin_make對自定義訊息進行編譯了。編譯完成之後，會在工作空間的 devel/include/【功能包名】路徑下生成自定義訊息的標頭檔案 stu.h 。編寫節點時只要包含了這個標頭檔案( #include<【功能包名】/ stu.h> )就可以使用這個訊息進行通訊了。使用該訊息型別建立訊息物件的方式為: 【功能包名】:: stu  物件名;  。

服務

自定義服務訊息

1）、定義 .srv 檔案

服務型別的定義格式：

變數的定義方式與話題訊息一致，即：資料型別+變數名，但與訊息不同的是，需要用三個短橫線(---)把請求資料和應答資料分隔開。 eg：我們自定義一個加法的服務addition.srv

2）、修改package.xml檔案，新增功能包依賴（同msg操作）

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

3）、修改CMakeLists.txt檔案，新增編譯選項（除新增的檔案不同，其他與msg操作相同）

find_package(...... message_generation) #生成自定義的訊息需要使用message_generation功能包

catkin_package(CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs message_runtime) #新增編譯依賴message_runtime

​add_service_files(FILES addition.srv) #新增服務型別檔案addition.srv
generate_messages(DEPENDENCIES  std_msgs) #新增生成依賴

經過以上三個步驟，我們就可以使用catkin_make對自定義服務進行編譯了。編譯完成之後，會在工作空間的 devel/include/【功能包名】路徑下生成自定義服務的標頭檔案 addition.h、additionRequest.h、additionResponse.h 。編寫節點時只要包含第一個標頭檔案( #include<【功能包名】/ addition.h> )就可以使用這個服務進行通訊了。使用該服務型別建立服務物件的方式為: 【功能包名】:: addition  物件名;  。

伺服器實現步驟大致如下：

1、初始化ROS節點

2、建立server例項

3、迴圈等待服務請求，接收到請求後進入回撥函式

4、在回撥函式中處理服務請求，並反饋應答資料

#include "ros/ros.h"
#include "a/addition.h"
// service回撥函式，輸入引數req，輸出引數res
bool add(a::addition::Request  &req, a::addition::Response &res)
{
  // 將輸入引數中的請求資料相加，結果放到應答變數中
  res.sum = req.a + req.b;
  ROS_INFO("request: x=%ld, y=%ld", (long int)req.a, (long int)req.b);
  ROS_INFO("sending back response: [%ld]", (long int)res.sum); 
  return true;
}
int main(int argc, char **argv)
{
  ros::init(argc, argv, "add_two_ints_server"); // ROS節點初始化
  ros::NodeHandle n;// 建立節點控制代碼
  // 建立一個名為add_two_ints的server，註冊回撥函式add()
  ros::ServiceServer service = n.advertiseService("add_two_ints", add);
  ROS_INFO("Ready to add two ints.");
  ros::spin();// 迴圈等待回撥函式
  return 0;
}

客戶端實現步驟大致如下：

1、初始化ROS節點

2、建立client例項

3、釋出服務請求

4、等待server處理之後的應答結果

#include <cstdlib>
#include "ros/ros.h"
#include "a/addition.h"
int main(int argc, char **argv)
{
  ros::init(argc, argv, "add_two_ints_client");// ROS節點初始化
  // 從終端命令列獲取兩個數
  if (argc != 3)
  {
    ROS_INFO("usage: add_two_ints_client X Y");
    return 1;
  }
  ros::NodeHandle n;// 建立節點控制代碼
  // 建立一個client，請求add_two_int service，service訊息型別是a::addition
  ros::ServiceClient client = n.serviceClient<a::addition>("add_two_ints");
  a::addition srv;// 建立a::addition型別的service訊息
  srv.request.a = atoll(argv[1]);
  srv.request.b = atoll(argv[2]);
  // 釋出service請求，等待加法運算的應答結果
  if (client.call(srv))
  {
    ROS_INFO("Sum: %ld", (long int)srv.response.sum);
  }
  else
  {
    ROS_ERROR("Failed to call service add_two_ints");
    return 1;
  }
  return 0;
}

修改CMakeLists檔案

1）、設定要編譯的檔案（同話題）

add_executable(server src/server.cpp)
add_executable(client src/client.cpp)

2）、設定連結庫（同話題）

target_link_libraries(server    ${catkin_LIBRARIES}  )
target_link_libraries(client    ${catkin_LIBRARIES}  )

3）、設定依賴（同話題）

add_dependencies(server ${PROJECT_NAME}_gencpp)
add_dependencies(client ${PROJECT_NAME}_gencpp)

編譯功能包

回到工作空間，執行catkin_make對功能包進行編譯。編譯完成後即可生成server和client兩個可執行檔案，然後就可以通過rosrun來運行了，效果如下：

[email protected]:~$ rosrun a client 1 2
[ INFO] [1537523575.202664700]: Sum: 3
[email protected]:~$ rosrun a server
[ INFO] [1537523561.898041700]: Ready to add two ints.
[ INFO] [1537523575.202092800]: request: x=1, y=2
[ INFO] [1537523575.202301100]: sending back response: [3]

動作

自定義動作訊息

1）、定義 .action檔案

服務型別的定義格式：

變數的定義方式與話題以及服務訊息一致，即：資料型別+變數名，但與訊息和服務不同的是，需要動作訊息需要用兩條由三個短橫線(---)構成的虛線把目標資訊、結果資訊和反饋資訊分隔開。 eg：我們自定義一個洗碗機的服務DoDishes.srv

第一部分定義的是目標資料，使用哪一臺洗碗機；第二部分定義的是結果資料，任務成功完成與否；第三部分定義的是週期反饋的狀態資料，任務完成的進度。

2）、修改package.xml檔案，新增功能包依賴

<build_depend>actionlib</build_depend> 
<build_depend>actionlib_msgs</build_depend> 
<exec_depend>actionlib</exec_depend> 
<exec_depend>actionlib_msgs</exec_depend>

3）、修改CMakeLists.txt檔案，新增編譯選項（除新增的檔案不同，其他與msg操作相同）

find_package(......  actionlib_msgs actionlib) #生成自定義的訊息需要使用 actionlib_msgs、actionlib功能包

​add_action_files(FILES DoDishes.action) #新增動作訊息檔案DoDishes.action
generate_messages(DEPENDENCIES  actionlib_msgs) #新增生成依賴

經過以上三個步驟，我們就可以使用catkin_make對自定義動作進行編譯了。編譯完成之後，會在工作空間的 devel/include/【功能包名】路徑下生成自定義動作的標頭檔案 DoDishesAction.h、DoDishesActionFeedback.h、DoDishesActionResult.h 、DoDishesResult.h、DoDishesActionGoal.h、DoDishesFeedback.h、DoDishesGoal.h。編寫節點時只要包含第一個標頭檔案( #include<【功能包名】/ DoDishesAction.h> )就可以使用這個動作進行通訊了。

伺服器實現步驟大致如下：

1、初始化ROS節點

2、建立action server例項

3、啟動伺服器，等待動作請求

4、接收到請求後進入回撥函式處理動作請求，並反饋進度資訊

5、動作完成，傳送結束資訊

#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include "a/DoDishesAction.h"
typedef actionlib::SimpleActionServer<a::DoDishesAction> Server;

// 收到action的goal後呼叫該回調函式
void execute(const a::DoDishesGoalConstPtr& goal, Server* as)
{
    ros::Rate r(1);
    a::DoDishesFeedback feedback;
    ROS_INFO("Dishwasher %d is working.", goal->dishwasher_id);
    // 假設洗盤子的進度平均為10%，並且按照1hz的頻率釋出進度feedback
    for(int i=1; i<=10; i++)
    {
        feedback.percent_complete = i * 10;
        as->publishFeedback(feedback);
        r.sleep();
    }
    // 當action完成後，向客戶端返回結果
    ROS_INFO("Dishwasher %d finish working.", goal->dishwasher_id);
    as->setSucceeded();
}

int main(int argc, char** argv)
{
    ros::init(argc, argv, "do_dishes_server");
    ros::NodeHandle n;
    // 定義一個伺服器
    Server server(n, "do_dishes", boost::bind(&execute, _1, &server), false);
    server.start();// 伺服器開始執行
    ros::spin();
    return 0;
}

客戶端實現步驟大致如下：

1、初始化ROS節點

2、建立action client例項

3、連線動作伺服器

4、傳送動作目標

5、根據伺服器的不同反饋資訊，處理回撥函式

#include <actionlib/client/simple_action_client.h>
#include "a/DoDishesAction.h"
typedef actionlib::SimpleActionClient<a::DoDishesAction> Client;

// 當action完成後會呼叫該回調函式一次
void doneCb(const actionlib::SimpleClientGoalState& state,
        const a::DoDishesResultConstPtr& result)
{
    ROS_INFO("Yay! The dishes are now clean");
    ros::shutdown();
}

// 當action啟用後會呼叫該回調函式一次
void activeCb()
{
    ROS_INFO("Goal just went active");
}

// 收到feedback後呼叫該回調函式
void feedbackCb(const a::DoDishesFeedbackConstPtr& feedback)
{
    ROS_INFO(" percent_complete : %f ", feedback->percent_complete);
}

int main(int argc, char** argv)
{
    ros::init(argc, argv, "do_dishes_client");
    Client client("do_dishes", true); // 定義一個客戶端
    ROS_INFO("Waiting for action server to start.");
    client.waitForServer(); // 等待伺服器端
    ROS_INFO("Action server started, sending goal.");
    a::DoDishesGoal goal;  // 建立一個action的goal
    goal.dishwasher_id = 1;
    // 傳送action的goal給伺服器端，並且設定回撥函式
    client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);
    ros::spin();
    return 0;
}

修改CMakeLists檔案

1）、設定要編譯的檔案（同話題）

add_executable(DoDishes_client src/DoDishes_client.cpp) 
add_executable(DoDishes_server src/DoDishes_server.cpp)

2）、設定連結庫（同話題）

target_link_libraries(DoDishes_client    ${catkin_LIBRARIES}  )
target_link_libraries(DoDishes_server    ${catkin_LIBRARIES}  )

3）、設定依賴（同話題）

add_dependencies(DoDishes_client ${${PROJECT_NAME}_EXPORTED_TARGETS})
add_dependencies(DoDishes_server ${${PROJECT_NAME}_EXPORTED_TARGETS})

編譯功能包

回到工作空間，執行catkin_make對功能包進行編譯。編譯完成後即可生成DoDishes_client和DoDishes_server兩個可執行檔案，然後就可以通過rosrun來運行了，效果如下：

[email protected]:~$ rosrun b DoDishes_client
[ INFO] [1537541980.774761400]: Waiting for action server to start.
[ INFO] [1537541981.204468700]: Action server started, sending goal.
[ INFO] [1537541981.205188000]: Goal just went active
[ INFO] [1537541981.206087300]:  percent_complete : 10.000000
[ INFO] [1537541982.205776000]:  percent_complete : 20.000000
[ INFO] [1537541983.205963000]:  percent_complete : 30.000000
[ INFO] [1537541984.205360000]:  percent_complete : 40.000000
[ INFO] [1537541985.205488100]:  percent_complete : 50.000000
[ INFO] [1537541986.205560800]:  percent_complete : 60.000000
[ INFO] [1537541987.205739900]:  percent_complete : 70.000000
[ INFO] [1537541988.205424100]:  percent_complete : 80.000000
[ INFO] [1537541989.205597000]:  percent_complete : 90.000000
[ INFO] [1537541990.205898500]:  percent_complete : 100.000000
[ INFO] [1537541991.208537400]: Yay! The dishes are now clean
[email protected]:~$ rosrun b DoDishes_server
[ INFO] [1537541981.205257600]: Dishwasher 1 is working.
[ INFO] [1537541991.207887100]: Dishwasher 1 finish working.

分散式通訊

前面我們介紹ros的時候提到，它是一種分散式的軟體框架，節點之間通過鬆耦合的方式進行組合。

多機通訊

設定IP地址，確認網路連通性

首先需要將 對方主機的ip地址和主機名 新增到 本機的 /etc/hosts 檔案 中：

sudo vi /etc/hosts

然後在終端中使用 ping 命令測試網路連通性。

[email protected]:~$ ping ldz-dell
PING ldz-dell (192.168.43.144) 56(84) bytes of data.
64 bytes from ldz-dell (192.168.43.144): icmp_seq=1 ttl=64 time=1415 ms
64 bytes from ldz-dell (192.168.43.144): icmp_seq=2 ttl=64 time=1587 ms
64 bytes from ldz-dell (192.168.43.144): icmp_seq=3 ttl=64 time=1450 ms
[email protected]:~$ ping MSI
PING MSI (192.168.43.64) 56(84) bytes of data.
64 bytes from MSI (192.168.43.64): icmp_seq=1 ttl=64 time=1351 ms
64 bytes from MSI (192.168.43.64): icmp_seq=2 ttl=64 time=1597 ms
64 bytes from MSI (192.168.43.64): icmp_seq=3 ttl=64 time=1692 ms

在從機中設定節點管理器所在的地址(ROS_MASTER_URI)

在 .bashrc檔案中追加一句，設定節點管理器的地址在主控機的11311埠，11311為節點管理器的預設埠，這裡的MSI是我的主控機主機名。

echo "export ROS_MASTER_URI=http://MSI:11311" >> ~/.bashrc
source ~/.bashrc

OK，經過以上配置，我們的多機通訊環境就搭建好了。只要我們就在主控機上執行節點管理器，所有從機上就都可以執行節點了，而不必在每個機器上都執行節點管理器。

相關推薦

ros 工作空間的覆蓋、c++程式設計介面實現通訊方式、自定義訊息格式、分散式多機通訊

工作空間的覆蓋 同一個工作空間下，不允許出現同名的功能包，否則無法編譯。不同工作空間下，允許出現同名的功能包，但會出現工作空間覆蓋的現象。 ros工作空間的路徑記錄在ROS_PACKAGE_PATH環境變數中，可以通過env命令檢視計算機中的環境變數，再利用管道過濾出有關

自定義訊息通知、手機震動、提示音

Android中自定義訊息通知、獲取手機震動、提示音，在此做下記錄 package com.wjy.project.railway.activity; import android.annotation.TargetApi; import android.app.Notification;

ros分散式多機通訊完整教程

ros多機通訊完整試坑教程 前言： 老規矩，先講講為啥要做這個專案。因為機器人上的工控機沒有辦法加顯示卡，所以無法跑TensorFlow-GPU，如果用CPU的話，一個是時間太長，二是消耗資源太多。 所以必須得將影象處理模組，放到筆記本上。剛好看到古月居大佬

C#程式設計基礎第四課2：使用if語句、if-else語句、多重if語句、巢狀if語句完成的C#控制檯小程式

知識點：基本算術運算、簡單if語句、if-else語句的練習。利用語句完成簡單C#控制檯程式。 1、運用if-else語句，判斷使用者輸入的年份是否是閏年 static void Main(string[] args) { /*

ROS 工作空間詳解

一、安裝ROS 官方教程http://wiki.ros.org/ROS/Installation或參考https://blog.csdn.net/bflong/article/details/80936914 二、管理環境變數 建立工作空間之前首先要確定環境變數都設定好，例如： RO

ros 工作空間以及功能包 建立編譯

組織結構： ros的目錄組織結構是工作空間name->src->功能包,這裡的工作空間名稱是test_ws,功能包（test1）位於src資料夾下面。 看一下package下面的目錄組織結構：tree test_ws/src/test1 -L 2（截圖

建立ROS工作空間

1、建立工作空間 在/home/你的使用者名稱目錄/下建立一個ROS工作空間，即資料夾catkin_ws,然後在工作空間 catkin_ws下建立一個資料夾src： $ mkdir -p ~/catkin_ws/src 開啟工作空間catkin_ws下的資料夾src：

ROS工作空間下建立一個新的package

建立一個包的最好方式是在catkin_ws下建立一個 catkin package1.先轉到catkin路徑下cd ~/catkin_ws/src2.用catkin_create_pkg 建立一個新包:catkin_create_pkg beginner_tutorials

C#精通C#程式設計：玩轉開發例項...C#程式設計入門、C#程式設計例項、C#開發例項與網路程式設計等....

            C#是微軟公司釋出的一種面向物件的、運行於.NET Framework之上的高階程式設計語言。並定於在微軟職業開發者論壇(PDC)上登臺亮相。C#是微軟公司研究員Anders Hejlsberg的最新成果。C#看起來與Java有著驚人的相似；它包

ROS總結——建立ROS工作空間

建立ROS工作空間 本部落格是對http://wiki.ros.org/上ROS教程的學習總結，歡迎大家交流學習。在http://blog.csdn.net/u010510350/article/de

【c++】模擬實現迴圈佇列 三種方法（標識、浪費一個空間、計數器）

什麼是迴圈佇列？ 為充分利用向量空間，克服”假溢位“現象的方法：將向量空間想象為一個首尾相接的圓環，並稱這種向量為迴圈向量。儲存在其中的佇列稱為迴圈佇列（Circular Queue）。 假象成如圖： 但實際上儲存空間還是一段連續的空間。 空佇列： 當有元素入隊時：

編譯ROS工作空間某一個包的命令

首先切換到自己的ROS工作空間： $ cd ~/catkin_ws如果你想編譯整個工作空間裡面的包：$ catkin_make如果你只想編譯工作空間某一個包：$ catkin_make -DCATK

七、C#入門基礎07(屬性和方法，結構和類、建構函式)

一、類 定義一個類時，等於定義了一個數據型別的藍圖。 這實際上並沒有定義任何的資料，但它定義了類的名稱意味著什麼，也就是說，類的物件由什麼組成及在這個物件上可執行什麼操作。 物件是類的例項。構成類的方法和變數成為類的成員。 類的定義: 類的定義是以關鍵字 class 開始，後跟

c++程式設計時為什麼老是出現cout未定義

#include <iostream> using namespace std; //加上這句 cout輸出流類宣告和定義都在iostream之中(對於非標準C++而言是iostream.h)其名字位於std空間，對於某些編譯器，特別是針對Windows平臺的開發

C語言介面實現2048小遊戲

這是我在大一第二學期（兩年前）為了參加比賽，自學後寫的一個Dome，拿出來和大家分享一下，程式碼為兩年前的程式碼，未改動，優化以及各式可能很一般，請見諒。 #include "stdio.h" #include "stdlib.h" #include "time.h" #d

android高仿抖音、點餐介面、天氣專案、自定義view指示、爬取美女圖片等原始碼

Android精選原始碼 Android優質部落格 簡介最近東西寫的挺多的，這不又要弄一個類似於京東的地址選擇器，然後剛開

linux c copyFile介面實現

LINUX本身並不提供拷貝檔案的介面，於是自己實現了一個。int copyFile(const char* src, const char* des) { int nRet = 0; FILE* pSrc = NULL, *pDes = NULL; pSrc = fo

[C#]利用介面實現多型性淺析

所謂的多型性，個人認為說的是相同的程式接受幾段毫不相同的引數而能正常的執行。而在C#中利用介面實現多型性我覺得並不是太嚴謹。我認為要真正實現多型性離不開泛型。 舉個小例子： public interface Iinter { publ

hadoop c++ pipes介面實現

（1）首先我們需要知道map-reduce的基本原理，這裡不說了。其次我們需要知道，在用C++編寫hadoop應用程式時，需要包含三個標頭檔案： #include "Pipes.hh" #include "TemplateFactory.hh" #include "StringUtils.hh" 這

C++程式設計例項——實現簡單的時間加減運算

C++是面向物件的程式語言，區別我們的C語言，具體程式設計首先要定義一個類，類中包含私有成員以及公有成員兩部分，私有成員主要是變數，公有成員主要是方法，另外還需要另外的.cpp程式來實現這些公有方法，以及一個主函式。一般的，外部對私有成員是不能直接訪問的，需要通