C++ 在OpenMP并行区域中使用矢量推回是否安全？

我知道我不应该在openmp并行区域内抛出任何未捕获的异常。因此，我认为以下循环不安全，因为vector的push_back函数可能会导致内存重新分配，从而可能引发异常

我查阅了文档，它说

如果发生了重新分配，如果元素的类型是可复制的或不可移动的，也会提供强有力的保证。

我的密码安全吗？Star是包含浮点数的基本数据结构

        std::vector<Star> stars;

        #pragma omp parallel for
        for(size_t i = 1; i < (gimg.height() - 1) * 2; i++)
        {
            float i_ = i / 2.0f;

            for(float j = 1; j < gimg.width() - 1; j += 0.5f)
            {
                //a b c
                //d e f
                //g h k

                quantum_t e = gimg.bilinear(j, i_);

                quantum_t a = gimg.bilinear(j - 1, i_ - 1);
                if(a >= e) continue;

                quantum_t b = gimg.bilinear(j, i_ - 1);
                if(b >= e) continue;

                quantum_t c = gimg.bilinear(j + 1, i_ + 1);
                if(c >= e) continue;

                quantum_t d = gimg.bilinear(j - 1, i_);
                if(d >= e) continue;

                quantum_t f = gimg.bilinear(j + 1, i_);
                if(f >= e) continue;

                quantum_t g = gimg.bilinear(j - 1, i_ + 1);
                if(g >= e) continue;

                quantum_t h = gimg.bilinear(j, i_ + 1); 
                if(h >= e) continue;

                quantum_t k = gimg.bilinear(j + 1, i_ + 1);
                if(k >= e) continue;

                bool ismax = d >= a && d >= g && h >= g && h >= k && f >= k && f >= c && b >= c && b >= a;

                if(ismax)
                {
                    Star s;
                    s.brightness = e;
                    s.location = Point<float>(j, i_);

                    #pragma omp critical
                    stars.push_back(s);
                }
            }
        }

std:：矢量星；
#pragma-omp并行
对于（尺寸i=1；i<（框架高度（）-1）*2；i++）
{
浮动i_u2;=i/2.0f；
对于（浮动j=1；j=e）继续；
量子t b=广义双线性（j，i_-1）；
如果（b>=e）继续；
量子c=广义双线性（j+1，i+1）；
如果（c>=e）继续；
量子d=广义双线性（j-1，i）；
如果（d>=e）继续；
量子f=广义双线性（j+1，i）；
如果（f>=e）继续；
量子t g=gimg.双线性（j-1，i_+1）；
如果（g>=e）继续；
量子h=gimg.双线性（j，i_+1）；
如果（h>=e）继续；
量子k=广义双线性（j+1，i+1）；
如果（k>=e）继续；
bool ismax=d>=a&&d>=g&&h>=g&&h>=k&&f>=k&&f>=c&&b>=c&&b>=a；
if（ismax）
{
星星s；
s、 亮度=e；
s、 位置=点（j，i_）；
#pragma-omp-critical
星星。向后推_（s）；
}
}
}

OpenMP标准在即将结束时指出：

在循环区域内执行的抛出必须导致执行恢复 在循环区域的相同迭代中，以及 抛出的异常必须捕获它

---

因此，使用

try

-

catch

构造将

push_back（）

封装在

critical

区域内，应该可以使代码安全。

如果抛出未捕获的异常是错误的，为什么不将

push_back

放在

try catch

中呢？