Question

我为我的工作项目制作了一个QT测试应用程序（一个带有GUI的应用程序，测试我所做的一些功能），但我的例外根本不起作用，我不明白为什么。也许我错过了一些东西，但代码似乎对我来说是正确的，这是一个样本：

抛出异常的函数（使用我的测试抛出std::invalid_argument）：

std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> cloud_manip::fragment_cloud(
        pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_ptr, float max_scaled_fragment_depth)
{
    if (!cloud_ptr)
    {
        throw invalid_cloud_pointer();
    }

    if ((aux::cmp_floats(max_scaled_fragment_depth, 0.00, 0.005)) || (max_scaled_fragment_depth < 0))
        throw std::invalid_argument("Invalid max fragment depth.");

    float curr_depth = FLT_MAX;
    std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> cloud_fragments;

    for (unsigned int cloud_it = 0; cloud_it < cloud_ptr->points.size(); cloud_it++)
    {
        // end of a fragment
        if ((cloud_ptr->points[cloud_it].y > (curr_depth + max_scaled_fragment_depth))
                || (cloud_ptr->points[cloud_it].y < (curr_depth - max_scaled_fragment_depth)) )
        {
            curr_depth = cloud_ptr->points[cloud_it].y;
            pcl::PointCloud<pcl::PointXYZRGB>::Ptr new_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
            cloud_fragments.push_back(new_cloud);
        }

        // filling current cloud
        else
            (cloud_fragments.back())->points.push_back(cloud_ptr->points[cloud_it]);
    }

    return cloud_fragments;
}

捕获异常的第一个函数：

pcl::PointCloud<pcl::PointXYZRGB>::Ptr fast_normal_estimation(pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_ptr, int max_neighbs,
                                                    float radius, float x_scale, float y_scale, float z_scale, float max_fragment_depth)
{
    try
    {
        // the cloud colored by its normal vectors; return value
        pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored_cloud_ptr;

        float max_scaled_fragment_depth = max_fragment_depth / y_scale;

        cloud_manip::scale_cloud(cloud_ptr, x_scale, y_scale, z_scale); // scaling cloud

        std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> cloud_fragments =
                cloud_manip::fragment_cloud(cloud_ptr, max_scaled_fragment_depth); // fragmenting cloud for less execution time

        // estimating the normals for each cloud fragment in parallel
        // #pragma omp parallel for schedule(static)
        for (unsigned int i = 0; i < cloud_fragments.size(); i++)
        {
            normal_estimation(cloud_fragments[i], radius, max_neighbs);
        }

        colored_cloud_ptr = cloud_manip::merge_clouds(cloud_fragments); // merging fragments to build original cloud

        cloud_manip::scale_cloud(colored_cloud_ptr, (1.0/x_scale), (1.0/y_scale), (1.0/z_scale));    // restoring widop scale

        return colored_cloud_ptr;
    }

    catch (const std::logic_error& le)
    {
        throw le;
    }
}

测试功能：

void test_normal_estimation(std::string import_path, std::string export_path, float radius,
                            int max_neighbs, float x_scale, float y_scale, float z_scale,
                            float max_fragment_depth)
{
    try
    {
        pcl::PointCloud<pcl::PointXYZRGB>::Ptr base_cloud;
        pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored_cloud;   // output cloud

        base_cloud = cloud_io::import_cloud(import_path);
        colored_cloud = fast_normal_estimation(base_cloud, max_neighbs, radius, x_scale, y_scale, z_scale,
                                               max_fragment_depth);
        cloud_io::export_cloud(export_path + "normal_estimation_test_" + boost::lexical_cast<std::string>(radius) + "_"
                                + boost::lexical_cast<std::string>(max_neighbs) + "_" + boost::lexical_cast<std::string>(x_scale) + "_"
                                + boost::lexical_cast<std::string>(y_scale) + "_" + boost::lexical_cast<std::string>(z_scale) + "_"
                                + boost::lexical_cast<std::string>(max_fragment_depth) + ".txt", colored_cloud);
    }

    catch(const std::logic_error& le)
    {
        throw le;
    }
}

最后是应该显示错误消息的接口：

void normal_estimation_test_form::on_launch_test_btn_clicked()
{
    // for when the test is done
    QMessageBox done;

    this->setEnabled(false);

    _ned->radius = ui->radius_dsb->value();
    _ned->max_neighbs = ui->max_neighbs_sb->value();
    _ned->x_scale = ui->x_scale_dsb->value();
    _ned->y_scale = ui->y_scale_dsb->value();
    _ned->z_scale = ui->z_scale_dsb->value();
    _ned->max_fragment_depth = ui->max_fragm_depth_sb->value();

    try
    {
        test_normal_estimation(_ned->cloud_in_path, _ned->cloud_out_path, _ned->radius,
                               _ned->max_neighbs, _ned->x_scale, _ned->y_scale,
                               _ned->z_scale, _ned->max_fragment_depth);

        done.setText("Cloud normal estimation test completed.");
        done.exec();
    }

    catch (const std::logic_error& le)
    {
        QErrorMessage q_err_msg;
        QString err_msg;

        err_msg.append("Invalid input.");
        q_err_msg.showMessage(err_msg, "Input Error");
    }
}

知道为什么我的异常根本没有被抓住了吗？提前谢谢。

edit_1：我知道我没有抓住std::invalid_argument，但这是因为根据cplusplus，它是std::logic_error的子类。

Answer 1

我找到了问题的答案，并在此解释：exception handling in Qt。它看起来不像是一种合法的方式，但我不知道更好。

为什么c ++ try-catch块不能在ubuntu上使用g ++？

1 个答案: