#include <string>#include <iostream>static int count = 0;class Counter{public:    Counter() { ++count; };    Counter(Counter& r) { ++count; };    Counter(Counter&& r) { ++count; };    ~Counter() { --count; };    void foo() {};};decltype(auto) foo_warn(){    Counter c;    return (c);             // Warning about returning local reference}decltype(auto) foo_no_warn(){    Counter c;    return 1==1 ? c : c;    // No warning,still local reference returned}int main(){    Counter& a = foo_warn();    Counter& b = foo_no_warn();    std::cout << count << std::endl;  // prints 0    a.foo();    b.foo();    return 0;}

代码编译命令：

g -6 -std = c 14 -Wall -O0 decl_fail.cpp -o decl_fail

输出：

g++-6 -std=c++14 -Wall -O0    decl_fail.cpp   -o decl_faildecl_fail.cpp: In function ‘decltype(auto) foo_warn()’:decl_fail.cpp:19:10: warning: reference to local variable ‘a’ returned [-Wreturn-local-addr]  Counter a;          ^

很明显,decltype(auto)返回表达式的引用(但仍然不直观),因此a和b是无效的引用(由count == 0证明).

问题是为什么编译器没有在foo_no_warn中警告我？

我刚刚在编译器中发现了一个错误,或者这是一些可以解释的行为？

您可以考虑以下代码：

typedef std::vector<int> Type;class DataContainer {public:    DataContainer() : data(Type(1024,0)) {}    const Type& getData() const { return data; }private:    const Type data;};const Type& returnLocalRef(){    DataContainer container;    const Type& data = container.getData();    return data; // o! returning a ref to local - no warning for most compilers}

虽然返回了本地引用,但是编译器在VS2015和gcc48(使用-Wall)中都不会发出警告.但是,如果您从const类型&数据编译器马上赶上问题.你应该考虑这样的行为有错误吗？值得商榷.

Compier的基本工作就是编译代码.它向开发人员警告一些明显的问题,但在大多数情况下,它不会对程序逻辑进行更深入的分析(编译时间会受到影响).
这是开发和应用的代码静态分析工具.

所描述的情况可以被认为是一个简单的例子,但单一级别的间接就足以“愚弄”编译器.由于要验证这一点,编译器将需要检查从getData方法实际返回的内容.

做一个简单的修改：

Type globalData;...const Type& getData() const { return globalData; }

将使returnLocalRef函数返回的引用有效.因此,这可以被认为是分析复杂性和时间效率之间的编译器的折衷.

为了将这些覆盖率报告导入SonarQube,我需要找到一种方法将它们组合成一个超级报告. ReportGenerator支持将多个报表合并为一个,但会创建HTML输出,这不是SonarQube可以使用的.

此时我的选择是

>手动滚动OpenCover报告合并(blech！)
>连续运行我的功能测试,大大增加故障反馈时间

我还缺少其他任何选择吗？

与此同时,除了你已经拥有的2之外,我想不出其他选择.

下面的例子可以方法1和方法2执行同一时间,在不同的线程上没有任何问题？

谢谢

class Test
{
    private readonly List<MyData> _data;

    public test()
    {
        _data = LoadData();
    }

    private List<MyData> LoadData()
    {
        //Get data from dv.
    }

    public void Method1()
    {
        foreach (var list in _data)
        {
            //do something
        }
    }

    public void Method2()
    {
        foreach (var list in _data)
        {
            //do something
        }
    }
}

从the docs：

A List<T> can support multiple
readers concurrently,as long as the
collection is not modified.
Enumerating through a collection is
intrinsically not a thread-safe
procedure. In the rare case where an
enumeration contends with one or more
write accesses,the only way to ensure
thread safety is to lock the
collection during the entire
enumeration. To allow the collection
to be accessed by multiple threads for
reading and writing,you must
implement your own synchronization.

(关于重复“本质上不是一个线程安全的过程”的观点是针对其他突变列表的).