c++语言中,使用vector是属于什么思想
时间: 2024-02-01 21:02:06 浏览: 21
在C++中,使用vector是属于面向对象编程思想中的容器类的使用。vector是一个动态数组,可以在运行时动态地分配和释放内存,并且支持在数组末尾快速添加和删除元素,提供了方便的数组访问方法和操作函数,是C++中非常常用的容器类之一。vector的使用可以大大简化程序的编写,提高程序的效率和可读性。
相关问题
用c++语言面对对象思想,再用vector构建二维数组,写出一个贪吃蛇代码。其中食物类构成,代码
好的,我会尽力回答你的问题。以下是基于C++语言和面向对象思想的贪吃蛇代码,其中使用了vector构建二维数组,同时实现了食物类。
```c++
#include <iostream>
#include <vector>
#include <conio.h>
#include <windows.h>
using namespace std;
// 坐标类
class Coordinate {
public:
int x;
int y;
Coordinate(int _x = 0, int _y = 0) {
x = _x;
y = _y;
}
};
// 食物类
class Food {
public:
Coordinate coordinate;
Food() {
srand((unsigned)time(NULL));
coordinate.x = rand() % 20;
coordinate.y = rand() % 20;
}
void generateFood() {
srand((unsigned)time(NULL));
coordinate.x = rand() % 20;
coordinate.y = rand() % 20;
}
};
// 贪吃蛇类
class Snake {
public:
vector<Coordinate> body;
Coordinate direction;
int length;
Snake() {
length = 3;
direction.x = 1;
direction.y = 0;
body.push_back(Coordinate(0, 0));
body.push_back(Coordinate(1, 0));
body.push_back(Coordinate(2, 0));
}
void move() {
// 计算蛇头新的位置
Coordinate newHead = body[length - 1];
newHead.x += direction.x;
newHead.y += direction.y;
// 判断蛇头是否与食物重合
bool isEatFood = (newHead.x == food.coordinate.x && newHead.y == food.coordinate.y);
// 将蛇头插入到身体最后面
body.push_back(newHead);
// 判断是否吃到了食物
if (!isEatFood) {
// 如果没有吃到食物,将蛇尾移除
body.erase(body.begin());
}
else {
// 如果吃到了食物,重新生成一个食物
food.generateFood();
length++;
}
}
bool isDead() {
// 判断蛇头是否超过边界
if (body[length - 1].x < 0 || body[length - 1].x >= 20 || body[length - 1].y < 0 || body[length - 1].y >= 20) {
return true;
}
// 判断蛇头是否与身体重合
for (int i = 0; i < length - 1; i++) {
if (body[i].x == body[length - 1].x && body[i].y == body[length - 1].y) {
return true;
}
}
return false;
}
private:
Food food;
};
// 游戏类
class Game {
public:
void start() {
while (true) {
// 清空屏幕
system("cls");
// 输出地图
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 20; j++) {
bool isSnake = false;
// 判断该位置是否为蛇身
for (int k = 0; k < snake.length; k++) {
if (snake.body[k].x == j && snake.body[k].y == i) {
isSnake = true;
break;
}
}
// 输出地图
if (isSnake) {
cout << "■";
}
else if (food.coordinate.x == j && food.coordinate.y == i) {
cout << "★";
}
else {
cout << "□";
}
}
cout << endl;
}
// 判断是否死亡
if (snake.isDead()) {
cout << "Game Over" << endl;
break;
}
// 接收用户输入
if (_kbhit()) {
switch (_getch()) {
case 'w':
if (snake.direction.y != 1) {
snake.direction.x = 0;
snake.direction.y = -1;
}
break;
case 's':
if (snake.direction.y != -1) {
snake.direction.x = 0;
snake.direction.y = 1;
}
break;
case 'a':
if (snake.direction.x != 1) {
snake.direction.x = -1;
snake.direction.y = 0;
}
break;
case 'd':
if (snake.direction.x != -1) {
snake.direction.x = 1;
snake.direction.y = 0;
}
break;
}
}
// 移动蛇
snake.move();
// 延时
Sleep(100);
}
}
private:
Snake snake;
Food food;
};
int main() {
Game game;
game.start();
return 0;
}
```
其中,贪吃蛇类包含了蛇的身体、移动方向和长度等信息,食物类包含了食物的位置信息,游戏类包含了游戏的开始、结束和循环等逻辑。整个游戏的流程如下:
1. 初始化贪吃蛇和食物,输出地图;
2. 接收用户输入,移动蛇;
3. 判断是否死亡,如果死亡则结束游戏,否则继续循环;
4. 延时一段时间,再次循环。
希望这个代码能够帮助到你!
用c++语言写一个DWA算法
好的,下面是一个简单的C++实现DWA算法的示例代码,仅供参考:
```cpp
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
// 定义机器人的状态结构体
struct RobotState {
double x, y, theta, v, w;
};
// 定义目标状态结构体
struct TargetState {
double x, y, theta;
};
// 定义障碍物结构体
struct Obstacle {
double x, y, r;
};
// 定义动态窗口结构体
struct DynamicWindow {
double v_min, v_max, w_min, w_max;
vector<double> vs, ws;
};
// 定义DWA算法类
class DWA {
public:
DWA(double _dt, double _v_min, double _v_max, double _w_min, double _w_max,
double _a_max, double _yaw_rate_max, double _dist_eps, double _angle_eps)
: dt(_dt), v_min(_v_min), v_max(_v_max), w_min(_w_min), w_max(_w_max),
a_max(_a_max), yaw_rate_max(_yaw_rate_max), dist_eps(_dist_eps), angle_eps(_angle_eps) {}
// 计算机器人当前状态与目标状态之间的距离和角度差
void calcDistAndAngle(const RobotState& robot_state, const TargetState& target_state,
double& dist, double& angle) {
dist = sqrt(pow(target_state.x - robot_state.x, 2) + pow(target_state.y - robot_state.y, 2));
angle = atan2(target_state.y - robot_state.y, target_state.x - robot_state.x) - robot_state.theta;
angle = normalizeAngle(angle);
}
// 计算机器人在某个速度和转向角下的运动轨迹
vector<RobotState> calcTrajectory(const RobotState& robot_state, double v, double w) {
vector<RobotState> traj;
traj.push_back(robot_state);
for (int i = 0; i < 10; ++i) {
RobotState next_state;
next_state.x = traj.back().x + v * cos(traj.back().theta) * dt;
next_state.y = traj.back().y + v * sin(traj.back().theta) * dt;
next_state.theta = traj.back().theta + w * dt;
next_state.v = v;
next_state.w = w;
traj.push_back(next_state);
}
return traj;
}
// 计算机器人在某个速度和转向角下的评分
double calcScore(const RobotState& robot_state, const TargetState& target_state,
const vector<Obstacle>& obstacles, double v, double w) {
double dist, angle;
calcDistAndAngle(robot_state, target_state, dist, angle);
if (dist > dist_eps || fabs(angle) > angle_eps) {
return 0.0;
}
// 计算机器人在当前速度和转向角下的运动轨迹
vector<RobotState> traj = calcTrajectory(robot_state, v, w);
// 计算机器人与障碍物的最小距离
double min_dist = INFINITY;
for (const auto& obs : obstacles) {
for (const auto& state : traj) {
double d = sqrt(pow(obs.x - state.x, 2) + pow(obs.y - state.y, 2)) - obs.r;
if (d < min_dist) {
min_dist = d;
}
}
}
// 根据最小距离和当前速度和转向角计算评分
double dist_score = exp(-min_dist / dist_eps);
double vel_score = (v - v_min) / (v_max - v_min);
double omega_score = (w - w_min) / (w_max - w_min);
return dist_score * vel_score * omega_score;
}
// 计算机器人的动态窗口
DynamicWindow calcDynamicWindow(const RobotState& robot_state) {
double v_prev = robot_state.v;
double w_prev = robot_state.w;
DynamicWindow dw;
dw.v_min = max(v_prev - a_max * dt, v_min);
dw.v_max = min(v_prev + a_max * dt, v_max);
dw.w_min = max(w_prev - yaw_rate_max * dt, w_min);
dw.w_max = min(w_prev + yaw_rate_max * dt, w_max);
for (double v = dw.v_min; v <= dw.v_max; v += 0.05) {
for (double w = dw.w_min; w <= dw.w_max; w += 0.1) {
double score = calcScore(robot_state, target_state, obstacles, v, w);
if (score > 0.0) {
dw.vs.push_back(v);
dw.ws.push_back(w);
}
}
}
return dw;
}
// 选择最优速度和转向角
void selectBestVelocity(const RobotState& robot_state, const TargetState& target_state,
const vector<Obstacle>& obstacles, RobotState& next_state) {
DynamicWindow dw = calcDynamicWindow(robot_state);
double best_score = -INFINITY;
double best_v = 0.0;
double best_w = 0.0;
for (int i = 0; i < dw.vs.size(); ++i) {
double score = calcScore(robot_state, target_state, obstacles, dw.vs[i], dw.ws[i]);
if (score > best_score) {
best_score = score;
best_v = dw.vs[i];
best_w = dw.ws[i];
}
}
next_state = robot_state;
next_state.v = best_v;
next_state.w = best_w;
next_state.theta += best_w * dt;
next_state.x += best_v * cos(next_state.theta) * dt;
next_state.y += best_v * sin(next_state.theta) * dt;
}
// 角度归一化到[-pi, pi]
double normalizeAngle(double angle) {
return atan2(sin(angle), cos(angle));
}
// 设置目标状态
void setTargetState(const TargetState& _target_state) {
target_state = _target_state;
}
// 设置障碍物
void setObstacles(const vector<Obstacle>& _obstacles) {
obstacles = _obstacles;
}
private:
double dt; // 时间步长
double v_min, v_max; // 速度的最小值和最大值
double w_min, w_max; // 转向角速度的最小值和最大值
double a_max; // 加速度的最大值
double yaw_rate_max; // 转向角速度的最大变化率
double dist_eps; // 距离容差
double angle_eps; // 角度容差
TargetState target_state; // 目标状态
vector<Obstacle> obstacles; // 障碍物
};
int main() {
// 初始化机器人状态、目标状态和障碍物
RobotState robot_state = {0, 0, 0, 0, 0};
TargetState target_state = {5, 5, 0};
vector<Obstacle> obstacles = {{2, 2, 1}, {3, 4, 1}, {4, 2, 1}};
// 初始化DWA算法
DWA dwa(0.1, 0.0, 1.0, -M_PI / 2, M_PI / 2, 0.5, M_PI / 4, 0.1, 0.1);
dwa.setTargetState(target_state);
dwa.setObstacles(obstacles);
// 执行DWA算法
while (true) {
RobotState next_state;
dwa.selectBestVelocity(robot_state, target_state, obstacles, next_state);
robot_state = next_state;
if (sqrt(pow(target_state.x - robot_state.x, 2) + pow(target_state.y - robot_state.y, 2)) < 0.1) {
break;
}
cout << "Robot state: (" << robot_state.x << ", " << robot_state.y << ", " << robot_state.theta << ")" << endl;
}
return 0;
}
```
该示例代码实现了一个简单的DWA算法,包括计算机器人与目标状态之间的距离和角度差、计算机器人在某个速度和转向角下的运动轨迹、计算机器人在某个速度和转向角下的评分、计算机器人的动态窗口、选择最优速度和转向角等功能。通过该示例代码,你可以了解到DWA算法的基本思想和实现方法。