C++ 为什么不'；tc++；尝试用g+捕捉块+；在ubuntu上？

我为我的工作项目制作了一个QT测试应用程序（一个带有GUI的应用程序，测试我制作的一些功能），但我的异常根本不起作用，我不明白为什么。也许我遗漏了一些东西，但代码对我来说似乎是正确的，下面是一个示例：

抛出异常的函数（在我的测试中它抛出

std:：invalid_参数

）：

你知道为什么我的异常没有被发现吗？先谢谢你

---

edit\u 1:我知道我没有捕捉到

std:：invalid\u参数

，但这是因为它是

std:：logic\u error

的一个子类。

我找到了问题的答案，并在这里进行了解释：。这看起来不是一个合法的方法，但我不知道还有更好的方法

如果在捕捉到

std:：logic_error

QT之后捕捉到

std:：invalid_argument

则会显示一条警告，告诉我

std:：invalid_argument

是

std:：logic_error

的一个子类，因此它总是被捕捉到

std:：logic_error

块中。你确定它抛出了吗？我已经使用调试器一步一步地检查了它步骤和是，输入

if

块。然后它抛出它，什么也没发生。我的

normal\u estimation\u test\u form

窗口被禁用（测试启动时应该禁用），但使用htop（ubuntu的任务管理器），我可以看到我的normal estimation函数没有运行（因为当它运行时，它以100%使用1个内核）。请发布一个。通过设计一个，你很可能会解决你的问题。请提供一个。

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");
    }
}