C++的for循环例程

当然，我可以提供一些 C 的 for 循环例程。下面是一个基本的 for 循环结构的示例：

#include <stdio.h>

int main() {
    int i;
    for (i = 1; i <= 10; i++) {
        printf("%d ", i);
    }
    return 0;
}

这个例程将输出从 1 到 10 的数字。在 for 循环中，我们首先初始化一个计数器变量 `i`，然后设置循环条件 `i <= 10`，最后在每次循环结束后递增计数器 `i`。在循环体内，我们使用 `printf` 函数打印出当前的计数器值。

希望这个例程能帮到你！如果你有其他问题，请随时提问。

相关问题

写一份 Gmapping SLAM的C++例程

以下是使用Gmapping SLAM库实现基本SLAM功能的C++例程：

#include <ros/ros.h>
#include <sensor_msgs/LaserScan.h>
#include <nav_msgs/OccupancyGrid.h>
#include <tf/transform_broadcaster.h>
#include <tf/transform_listener.h>
#include <gmapping/gridfastslam/gridslamprocessor.h>

class GmappingSLAM
{
public:
    GmappingSLAM();
    void laserCallback(const sensor_msgs::LaserScan::ConstPtr& scan);

private:
    ros::NodeHandle nh_;
    ros::Subscriber laser_sub_;
    ros::Publisher map_pub_;
    tf::TransformBroadcaster tf_broad_;
    tf::TransformListener tf_listener_;
    GMapping::GridSlamProcessor* gsp_;
    bool initialized_;
    int laser_count_;
    ros::Time last_update_;
    double max_range_;
    double max_urange_;
};

GmappingSLAM::GmappingSLAM()
{
    laser_sub_ = nh_.subscribe<sensor_msgs::LaserScan>("scan", 1, &GmappingSLAM::laserCallback, this);
    map_pub_ = nh_.advertise<nav_msgs::OccupancyGrid>("map", 1);
    gsp_ = new GMapping::GridSlamProcessor();
    initialized_ = false;
    laser_count_ = 0;
    last_update_ = ros::Time::now();
    max_range_ = 8.0;
    max_urange_ = 0.5;
}

void GmappingSLAM::laserCallback(const sensor_msgs::LaserScan::ConstPtr& scan)
{
    if(!initialized_)
    {
        gsp_->setSensorMap(*(gsp_->getMatchSensor()));
        gsp_->init();
        initialized_ = true;
    }

    tf::StampedTransform laser_pose;
    try
    {
        tf_listener_.waitForTransform("map", scan->header.frame_id, scan->header.stamp, ros::Duration(1.0));
        tf_listener_.lookupTransform("map", scan->header.frame_id, scan->header.stamp, laser_pose);
    }
    catch(tf::TransformException& ex)
    {
        ROS_ERROR("%s", ex.what());
        return;
    }

    GMapping::OrientedPoint odom_pose;
    odom_pose.x = laser_pose.getOrigin().x();
    odom_pose.y = laser_pose.getOrigin().y();
    odom_pose.theta = tf::getYaw(laser_pose.getRotation());

    if(!gsp_->processScan(*scan))
    {
        ROS_WARN("Scan skipped.");
        return;
    }

    if(laser_count_ > 30 && (ros::Time::now() - last_update_).toSec() > 5.0)
    {
        last_update_ = ros::Time::now();
        GMapping::GridMap map;
        gsp_->getParticles()[gsp_->getBestParticleIndex()].map(map);
        nav_msgs::OccupancyGrid map_msg;
        map_msg.header.stamp = ros::Time::now();
        map_msg.header.frame_id = "map";
        map_msg.info.resolution = map.getResolution();
        map_msg.info.width = map.getMapSizeX();
        map_msg.info.height = map.getMapSizeY();
        map_msg.info.origin.position.x = map.getWorldCoordsX(0, 0);
        map_msg.info.origin.position.y = map.getWorldCoordsY(0, 0);
        map_msg.info.origin.orientation.w = 1.0;
        map_msg.data.resize(map_msg.info.width * map_msg.info.height, -1);
        for(int i = 0; i < map_msg.info.width; ++i)
        {
            for(int j = 0; j < map_msg.info.height; ++j)
            {
                if(map.isInside(i, j))
                {
                    GMapping::IntPoint p(i, j);
                    double occ = map.cell(p);
                    if(occ >= 0.0 && occ <= 1.0)
                    {
                        map_msg.data[i + j * map_msg.info.width] = static_cast<int8_t>(occ * 100);
                    }
                    else if(occ < 0.0)
                    {
                        map_msg.data[i + j * map_msg.info.width] = -1;
                    }
                    else if(occ > 1.0)
                    {
                        map_msg.data[i + j * map_msg.info.width] = 100;
                    }
                }
            }
        }
        map_pub_.publish(map_msg);
        tf::StampedTransform map_to_odom;
        map_to_odom.setIdentity();
        map_to_odom.frame_id_ = "map";
        map_to_odom.child_frame_id_ = "odom";
        map_to_odom.stamp_ = ros::Time::now();
        map_to_odom.setOrigin(tf::Vector3(odom_pose.x, odom_pose.y, 0.0));
        tf_broad_.sendTransform(map_to_odom);
    }

    ++laser_count_;
}

int main(int argc, char** argv)
{
    ros::init(argc, argv, "gmapping_slam");
    GmappingSLAM gmapping_slam;
    ros::spin();
    return 0;
}

这个例程实现了一个ROS节点，用于从LaserScan消息中读取激光雷达数据，并使用Gmapping SLAM库进行地图构建。在ROS节点中定义了一个GmappingSLAM类，其中包含一个激光雷达数据的订阅者、一个地图数据的发布者和一个GMapping::GridSlamProcessor对象。在类构造函数中，设置了一些初始值，如最大检测范围、最大不确定范围等。

在laserCallback()回调函数中，首先判断是否已经初始化。如果没有初始化，则调用GMapping::GridSlamProcessor对象的setSensorMap()和init()方法进行初始化。然后，使用tf库将激光雷达数据的坐标系转换到地图坐标系下，并计算机器人在地图上的位姿。最后，使用GMapping::GridSlamProcessor对象的processScan()方法进行地图构建。如果构建失败，则跳过该次激光雷达数据的处理。如果已经累计了一定数量的激光雷达数据，并且距离上次地图更新时间超过了一定时间，则发布地图数据，并将机器人在地图坐标系下的位姿通过tf库广播出去。

最后，在main()函数中，初始化ROS节点并创建一个GmappingSLAM类对象，然后进入ROS节点的循环处理函数。

ffmpeg rtsp拉流后再使用rtsp推流 c++ 例程

FFmpeg是一个强大的跨平台多媒体处理框架，可以用于实时传输协议（RTSP）的流媒体操作，包括拉取（playback）和推送（publish）。在C++中，你可以通过FFmpeg库的API来完成这个任务。以下是一个简单的示例，展示了如何使用FFmpeg从RTSP源拉流，并将该流作为新的RTSP发布：

#include <iostream>
#include <string>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"

int main(int argc, char** argv) {
    // 拉取RTSP输入流
    const std::string input_url = "rtsp://your_input_url";
    AVFormatContext* fmt_ctx_in = nullptr;
    if (avformat_open_input(&fmt_ctx_in, input_url.c_str(), NULL, NULL) != 0) {
        std::cerr << "Failed to open input RTSP stream." << std::endl;
        return -1;
    }

    if (avformat_find_stream_info(fmt_ctx_in, NULL) < 0) {
        std::cerr << "Failed to find stream info." << std::endl;
        avformat_close_input(&fmt_ctx_in);
        return -1;
    }

    // 创建输出文件上下文
    const std::string output_url = "rtsp://your_output_url";
    AVFormatContext* fmt_ctx_out = avformat_alloc_context();
    avformat_set_output_format(fmt_ctx_out, "application/x-rtp", "rtp", output_url.c_str());

    // 处理并复制音频/视频流
    for (int i = 0; i < fmt_ctx_in->nb_streams; ++i) {
        AVStream* in_stream = fmt_ctx_in->streams[i];
        AVStream* out_stream = avformat_new_stream(fmt_ctx_out, in_stream->codec);

        // 如果需要，可以在这里调整编码设置

        avcodec_copy_context(out_stream->codec, in_stream->codec);
        out_stream->time_base = in_stream->time_base;
    }

    // 写入并开始推流
    if (avio_open(&fmt_ctx_out->pb, output_url.c_str(), AVIO_FLAG_WRITE) < 0) {
        std::cerr << "Failed to open output file." << std::endl;
        return -1;
    }
    int ret = avformat_write_header(fmt_ctx_out, NULL);
    if (ret < 0) {
        std::cerr << "Failed to write header." << std::endl;
        avio_close(&fmt_ctx_out->pb);
        return -1;
    }
    
    AVPacket packet;
    while (true) {
        int got_packet = av_read_frame(fmt_ctx_in, &packet);
        if (!got_packet) {
            break;
        }
        
        av_interleaved_write_frame(fmt_ctx_out, &packet);
        av_packet_unref(&packet);
    }

    // 关闭并释放资源
    av_write_trailer(fmt_ctx_out);
    avformat_close_input(&fmt_ctx_in);
    avio_close(&fmt_ctx_out->pb);
    avformat_free_context(fmt_ctx_out);
    
    std::cout << "Streaming completed." << std::endl;
    return 0;
}

注意：这只是一个基础示例，实际应用中可能需要添加错误处理、解码/编码选项以及循环读取处理帧等。同时，请替换`your_input_url`和`your_output_url`为你所需的输入和输出RTSP地址。