面试题

用 C++写一个函数，交换两个整型变量

int a = 5, b = 10;
cout << "Before swapping: a = " << a << ", b = " << b << endl;
swapVars<int>(a, b);
cout << "After swapping: a = " << a << ", b = " << b << endl;

double c = 1.23, d = 4.56;
cout << "Before swapping: c = " << c << ", d = " << d << endl;
swapVars<double>(c, d);
cout << "After swapping: c = " << c << ", d = " << d << endl;

用 c++语言，实现先进先出的队列

#include 

using namespace std;

// 定义队列节点结构体
struct Node {
    int val;  // 节点值
    Node* next;  // 指向下一个节点的指针

    // 构造函数
    Node(int val): val(val), next(nullptr) {}
};

// 定义链式队列
class Queue {
private:
    Node* head;  // 队首指针
    Node* tail;  // 队尾指针

public:
    // 构造函数
    Queue(): head(nullptr), tail(nullptr) {}

    // 判断队列是否为空
    bool isEmpty() {
        return (head == nullptr);
    }

    // 入队操作
    void enqueue(int val) {
        Node* node = new Node(val);
        if (isEmpty()) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }

    // 出队操作
    int dequeue() {
        if (isEmpty()) {
            return -1;
        }
        int val = head->val;
        Node* temp = head;
        head = head->next;
        delete temp;
        return val;
    }

    // 获取队首元素
    int front() {
        if (isEmpty()) {
            return -1;
        }
        return head->val;
    }

    // 获取队列长度
    int size() {
        int count = 0;
        Node* cur = head;
        while (cur) {
            count++;
            cur = cur->next;
        }
        return count;
    }
};

int main() {
    // 创建一个空队列
    Queue q;

    // 将元素依次加入队列
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    q.enqueue(4);
    q.enqueue(5);

    // 输出队列中的元素
    while (!q.isEmpty()) {
        cout << q.front() << " ";  // 输出队首元素
        q.dequeue();  // 弹出队首元素
    }
    cout << endl;

    return 0;
}

用 c++语言，实现二叉树基本操作。

#include 

using namespace std;

// 定义二叉树节点结构体
struct TreeNode {
    int val;  // 节点值
    TreeNode* left;  // 左子节点指针
    TreeNode* right;  // 右子节点指针

    // 构造函数
    TreeNode(int val): val(val), left(nullptr), right(nullptr) {}
};

// 创建二叉树
TreeNode* createTree() {
    int val;
    cin >> val;
    if (val == -1) {  // 输入-1表示空节点
        return nullptr;
    }
    TreeNode* node = new TreeNode(val);
    node->left = createTree();  // 递归创建左子树
    node->right = createTree();  // 递归创建右子树
    return node;
}

// 先序遍历
void preOrder(TreeNode* root) {
    if (root) {
        cout << root->val << " ";  // 输出节点值
        preOrder(root->left);  // 递归遍历左子树
        preOrder(root->right);  // 递归遍历右子树
    }
}

// 中序遍历
void inOrder(TreeNode* root) {
    if (root) {
        inOrder(root->left);  // 递归遍历左子树
        cout << root->val << " ";  // 输出节点值
        inOrder(root->right);  // 递归遍历右子树
    }
}

// 后序遍历
void postOrder(TreeNode* root) {
    if (root) {
        postOrder(root->left);  // 递归遍历左子树
        postOrder(root->right);  // 递归遍历右子树
        cout << root->val << " ";  // 输出节点值
    }
}

int main() {
    // 创建二叉树
    TreeNode* root = createTree();

    // 输出各种遍历结果
    cout << "先序遍历结果：";
    preOrder(root);
    cout << endl;

    cout << "中序遍历结果：";
    inOrder(root);
    cout << endl;

    cout << "后序遍历结果：";
    postOrder(root);
    cout << endl;

    return 0;
}

用 C++或 Python 实现观察者模式。

#include 
#include 

using namespace std;

// 抽象主题类
class Subject {
public:
    virtual void attach(Observer* observer) = 0;  // 添加观察者
    virtual void detach(Observer* observer) = 0;  // 移除观察者
    virtual void notify() = 0;  // 通知观察者
};

// 具体主题类
class ConcreteSubject : public Subject {
private:
    vector<Observer*> observers;  // 观察者列表
    int state;  // 主题状态

public:
    // 添加观察者
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    // 移除观察者
    void detach(Observer* observer) {
        for (auto it = observers.begin(); it != observers.end(); it++) {
            if (*it == observer) {
                observers.erase(it);
                break;
            }
        }
    }

    // 通知观察者
    void notify() {
        for (auto observer : observers) {
            observer->update(state);
        }
    }

    // 设置主题状态
    void setState(int state) {
        this->state = state;
        notify();  // 状态改变后通知观察者
    }
};

// 抽象观察者类
class Observer {
public:
    virtual void update(int state) = 0;  // 更新观察者状态
};

// 具体观察者类
class ConcreteObserver : public Observer {
public:
    // 更新观察者状态
    void update(int state) {
        cout << "观察者收到主题状态更新，新状态为：" << state << endl;
    }
};

int main() {
    ConcreteSubject* subject = new ConcreteSubject();  // 创建主题对象
    ConcreteObserver* observer1 = new ConcreteObserver();  // 创建观察者对象1
    ConcreteObserver* observer2 = new ConcreteObserver();  // 创建观察者对象2

    subject->attach(observer1);  // 添加观察者1
    subject->attach(observer2);  // 添加观察者2

    subject->setState(1);  // 设置主题状态为1

    subject->detach(observer1);  // 移除观察者1

    subject->setState(2);  // 设置主题状态为2

    return 0;
}

# 抽象主题类
class Subject:
    def attach(self, observer):
        pass

    def detach(self, observer):
        pass

    def notify(self):
        pass

# 具体主题类
class ConcreteSubject(Subject):
    def __init__(self):
        self.observers = []  # 观察者列表
        self.state = 0  # 主题状态

    # 添加观察者
    def attach(self, observer):
        self.observers.append(observer)

    # 移除观察者
    def detach(self, observer):
        self.observers.remove(observer)

    # 通知观察者
    def notify(self):
        for observer in self.observers:
            observer.update(self.state)

    # 设置主题状态
    def set_state(self, state):
        self.state = state
        self.notify()  # 状态改变后

思考一下，怎么抓住目标物体？

1. 首先，使用摄像头获取机械臂下方物体的位置和姿态信息。
2. 根据物体的位置和姿态信息，计算出机械臂末端的目标位置和姿态。
3. 使用逆运动学求解机械臂需要移动的关节角度，使末端可以到达目标位置和姿态。由于机械臂有两个自由度，需要求解两个关节的角度。
4. 将机械爪移动到末端，抓取物体
   需要注意的是，机械臂的运动要考虑到安全性和稳定性，需要避免碰撞和过度运动造成的摆动。此外，还需要考虑机械臂和机械爪的精度和可靠性，以确保抓取成功率。

以下是一个基于ROS和MoveIt的Python代码示例，实现了一个2自由度机械臂的抓取任务。

i

mport rospy
import moveit_commander
from geometry_msgs.msg import PoseStamped

# 初始化
rospy.init_node('pick_and_place')
robot = moveit_commander.RobotCommander()
group = moveit_commander.MoveGroupCommander('arm')
gripper = moveit_commander.MoveGroupCommander('gripper')

# 设置目标位置和姿态
target_pose = PoseStamped()
target_pose.header.frame_id = 'base_link'
target_pose.pose.position.x = 0.4
target_pose.pose.position.y = 0.0
target_pose.pose.position.z = 0.1
target_pose.pose.orientation.x = 0.0
target_pose.pose.orientation.y = 0.0
target_pose.pose.orientation.z = 0.0
target_pose.pose.orientation.w = 1.0

# 移动机械臂
group.set_pose_target(target_pose)
plan = group.plan()
group.execute(plan)

# 打开机械爪
gripper.set_joint_value_target([0.04])
plan = gripper.plan()
gripper.execute(plan)

# 移动机械爪到目标位置
target_pose.pose.position.z = 0.07
group.set_pose_target(target_pose)
plan = group.plan()
group.execute(plan)

# 关闭机械爪
gripper.set_joint_value_target([0.0])
plan = gripper.plan()
gripper.execute(plan)

# 移动机械臂回到初始位置
target_pose.pose.position.x = 0.0
target_pose.pose.position.y = 0.0
target_pose.pose.position.z = 0.2
group.set_pose_target(target_pose)
plan = group.plan()
group.execute(plan)

在这个示例代码中，我们使用了ROS和MoveIt来控制机械臂的运动。首先，我们初始化了ROS节点和MoveIt中的RobotCommander、MoveGroupCommander和GripperCommander。然后，我们设置了目标位置和姿态，将机械臂移动到目标位置。接下来，我们打开机械爪，将机械爪移动到目标位置，关闭机械爪，最后将机械臂移动回初始位置。