GCC笔下平凡可复制类型的原子对象
GCC是GNU Compiler Collection的缩写，是一套由GNU开发的编程语言编译器集合。它支持多种编程语言，包括C、C++、Objective-C、Fortran、Ada等。GCC的主要目标是生成高质量的可执行文件，并提供丰富的优化选项和调试功能。
在GCC中，"笔下平凡可复制类型的原子对象"这个描述并不是一个具体的名词或概念，因此无法给出相关的分类、优势、应用场景以及腾讯云相关产品推荐。如果有具体的名词或概念需要解释和讨论，请提供更详细的问题描述。
相关·内容
我有一个函数需要执行n=1000次。此函数执行蒙特卡洛风格的模拟，并返回一个int作为结果。我想并行运行nthreads=4。每当线程完成一个周期时，它都应该将结果放入std::vector<int>中。因此，在1000次循环之后，我得到了一个1000 int的向量，可以通过统计进行检查。
因为std::vector不是线程安全的，所以我想到了std::mutex (它肯定可以工作)。
但是我想知道我是否可以声明一个向量是原子的，从而绕过互斥锁？有没有可能有一个std::atomic<std::vector<int>>？我可以在上面使用push_back等吗
浏览 4提问于2015-09-21得票数 24
回答已采纳
这两个编译器中的任何一个仍然不支持std::is_trivially_copyable (至少在gcc 4.6中是如此)。但两者都提供了做得很好的__has_trivial_copy指令。除非涉及到已删除的复制构造函数。
struct A { A(A const&) =delete; };
__has_trivial_copy(A)在clang中返回1，在gcc中返回0。
我在深入研究这个标准，但找不到一个子句，说明在删除复制构造函数时，类是否仍然被认为是微不足道的可复制的。
谁是对的？
我的倾向是相信gcc是对的，因为struct A根本不能被复制，更不要说微不足道的抄袭了。此外，有
浏览 5提问于2012-10-05得票数 7
1回答
请考虑以下代码。它可以与Clang和GCC合编。然而，GCC发出警告：
警告：'void* memcpy(void*，const *，size_t)‘写入非复制类型的“struct值”；使用复制赋值或复制初始化代替-Wclass。
#include <cstring>
#include <iostream>
#include <type_traits>
static unsigned cnt2 = 0;
struct Value {
Value(int v) noexcept : v(v), m(v+1) { }
~Value()
浏览 1提问于2020-06-18得票数 2
它们什么时候会给出不同的答案，这种差异什么时候会有用？
浏览 6提问于2013-05-14得票数 24
回答已采纳
2回答
C++11标准保证字节对字节的副本始终对POD类型有效.但是某些琐碎的类型呢？
下面是一个例子：
struct trivial
{
int x;
int y;
trivial(int i) : x(2 * i) { std::cout << "Constructed." << std::endl; }
};
如果我要复制这个结构，字节对字节，它是否保证正确地复制，即使技术上它不是POD？当字节复制对象不合适时，什么时候画的线是画的？
浏览 1提问于2011-09-24得票数 5
回答已采纳
std::cout << std::boolalpha;
std::cout << std::is_trivially_copyable< std::pair<const int,int> >::value;
std::cout << std::is_trivially_copyable< std::pair<int,int> >::value;
当我使用GCC 9.2时，输出是true false。
当我使用clang5.0或GCC 5.2时，输出是false false。
为什么会有不同？
浏览 1提问于2019-10-08得票数 7
我们有以下方法来测试我们的结构是否是POD。它总是返回true：
bool podTest() {
struct podTest {
int count;
int x[];
};
return std::is_pod<podTest>::value; //Always returns true
}
到目前一切尚好。现在，我们做一个更改并删除复制构造函数：
bool podTest() {
struct podTest {
podTest(const podTest&) = delete;
int count;
in
浏览 2提问于2017-02-06得票数 9
回答已采纳
1回答
我有以下程序：
#include <initializer_list>
#include <iostream>
class A;
class nih {
public:
virtual void apply(A & a) const { std::cout << "generic" << std::endl; };
};
union niit;
class A {
public:
int s; char kau;
A() : s(1), kau('-') { }
A(std::ini
浏览 0提问于2012-01-12得票数 1
回答已采纳
1回答
随着c++11的引入，变得非常重要。最值得注意的是在使用‘std：：原子’。基本的东西很简单。在以下情况下，类foo是可以复制的：
foo* src = new foo();
foo* dest = malloc(sizeof(foo));
memcpy(dest, src, sizeof(foo));
其效果与以下情况相同：
foo* src = new foo();
foo* dest = new foo(src);
因此，复制内存的对象将具有与复制构造函数相同的效果。然而，当然，这是一个陷阱。不仅仅是复制构造函数。也可以移动构造函数，移动赋值操作符。等。
可以用来测试一个对象是否具有可复
浏览 3提问于2015-05-07得票数 21
回答已采纳
1回答
我用GCC和Clang尝试了这个程序，但都没有输出任何内容
#include <iostream>
struct A {
A(){}
template<typename T>
A(T &) {
std::cout << "copied!";
}
};
void f(...) { }
int main() {
A a;
f(a);
}
根据我的标准阅读，这个程序应该输出"copied!"。有没有人能告诉我，我是错了还是这两个编译器有个bug？
浏览 1提问于2012-11-04得票数 8
对于类型T，请考虑：
void f(T z)
{
T a;
T b;
std::memcpy(&b, &a, sizeof(T));
a = z;
b = z;
// ...
}
是在C++14中定义的此片段的行为，如果
T是char，
T是int，或
T是结构{ int数据；}；？
假设f被传递了一个包含有效值的对象。
如果将对memcpy的调用替换为复制赋值b = a，则答案是否更改？
是否可以将结果转到复制构造T(a)和移动构造/分配
Note：与不同的是，这个问题特别关注复制不确定值的角落情况。
浏览 6提问于2015-10-07得票数 2
回答已采纳
我已经注意到，move可以应用于做而不是的对象，它有一个“非平凡”的联合(不确切地知道，但例如原语类型很好)。例如，以下代码编译(C++14、Clang)：
#include <vector>
#include <string>
class Foo {
public:
union {
int i;
bool b;
};
Foo() {};
~Foo() {};
// Move constructor to default.
Foo(Foo &&) = default;
// Copy construct
浏览 1提问于2017-11-04得票数 0
回答已采纳
#include <iostream>
struct A {
const int test_;
};
static_assert(std::is_pod<A>::value, "must be POD type");
int main()
{
std::cout<<"Hello World";
return 0;
}
在Clang和GCC上，std::is_pod<A>::value是true，而在ICC和MSVC上是false。
如果const int test_;被替换为int tes
浏览 3提问于2021-06-09得票数 7
考虑一下Foo的以下定义
struct Foo {
uint64_t data;
};
现在，考虑Bar的以下定义，它具有与Foo相同的数据成员，但有一个空的用户声明的析构函数：
struct Bar {
~Bar(){} // <-- empty user-declared dtor
uint64_t data;
};
gcc 8.2与-O2的函数copy_foo()
void copy_foo(const Foo* src, Foo* dst, size_t len) {
std::copy(src, src + len, dst);
}
结果显示以
浏览 0提问于2018-09-11得票数 6
回答已采纳
基于C++标准。普通可复制类定义如下：
根据9/5，
A trivially copyable class is a class that:
- has no non-trivial copy constructors (12.8),
- has no non-trivial move constructors (12.8),
- has no non-trivial copy assignment operators (13.5.3, 12.8),
- has no non-trivial move assignment operators (13.5.3, 12.8), and
- has
浏览 8提问于2014-03-19得票数 4
回答已采纳
为了克服对齐问题，我需要将memcpy转换为临时的。应该是什么类型的临时性的？gcc抱怨以下reinterpret_cast会违反严格的别名规则：
template <typename T>
T deserialize(char *ptr) {
static_assert(std::is_trivially_copyable<T>::value, "must be trivially copyable");
alignas(T) char raw[sizeof(T)];
memcpy(raw, ptr, sizeof(T));
浏览 10提问于2016-09-02得票数 11
我得到的SSE代码是为x64写的，堆栈是16对齐的。优化的代码路径现在已经针对32位x86 (适用于MSVC/Windows和GCC/Linux)请求。首先让它在MSVC上工作。
现在，除了一些接受超过3个__m128参数的内联，它拒绝编译这些参数(通过创建const引用并希望编译器优化它来修复)，所有的东西似乎都可以按原样工作。
//error C2719: 'd': formal parameter with __declspec(align('16')) won't be aligned
inline __m128i foo(__m128i a,
浏览 0提问于2013-07-22得票数 2
似乎std::atomic类型不是复制可构造的或复制可赋值的。为什么？
复制原子类型不可能有什么技术原因吗？或者，接口被限制是为了避免某种不好的代码？
浏览 1提问于2013-03-06得票数 25
回答已采纳
GCC 7.2和Clang 5.0在这种情况下不同意：
struct A;
A foo();
struct A
{
static void bar()
{
foo();
}
private:
~A()=default;
};
A foo()
{
return {};
//GCC error: A::~A() is private in this context.
};
这种行为是"c++17保证(复制省略，而不是相关的RVO或NRVO)“的一部分。
GCC不编译这个代码，但是Clang编译。哪一个是错的？
也许这一
浏览 1提问于2017-10-03得票数 5
回答已采纳
1回答
在从GCC用C++0x编译的MinGW代码main返回后，我一直在努力解决分段错误，并将其缩小到简单的情况：
class A {
public:
virtual ~A();
};
A::~A() {
}
const A a;
int main() {
return 0;
}
其原因与以下因素有关：
对象之前的const限定符，删除它将停止seg错误，
class A中缺少构造函数--添加空构造函数可以阻止seg错误。
版本的增强型-更新的TDM MinGW与gcc 4.8.1不构建代码导致seg故障。
是我触发了一些未定义的行为，还是真正的编译器错误是
浏览 4提问于2014-07-15得票数 2
回答已采纳
1回答
在GCC 4.6.1上，当我声明一个具有默认构造函数的属于我自己类型的实例时，如果我实例化该类型的对象并使用大括号(如Foo my_foo{}；)初始化它，那么如果没有其他声明的构造函数，该类中的POD成员将仅为零初始化。如果除了默认构造函数之外，没有其他构造函数，则它们将与预期的一样为零。
但是，在GCC 4.7.3上，零初始化发生在任何一种情况下，这就是我所期望的行为。
这里有什么区别？这是编译器的错误吗？这两种GCC版本都支持C++11标准的默认构造函数。
没有必要坚持老GCC的版本，但我想了解一下这里发生了什么。
注意:我正在默认主控制器，op=。并且复制ctor仅仅是为了保持类型在各
浏览 4提问于2013-09-19得票数 6
回答已采纳
2回答
我打算声明一个原子变量向量，作为多线程程序中的计数器。以下是我尝试过的：
#include <atomic>
#include <vector>
int main(void)
{
std::vector<std::atomic<int>> v_a;
std::atomic<int> a_i(1);
v_a.push_back(a_i);
return 0;
}
这就是gcc 4.6.3的令人恼火的错误信息：
In file included from /usr/include/c++/4.6/x86_64-linux
浏览 12提问于2012-11-02得票数 46
回答已采纳
在 in C++11中，我的理解是以下结构被认为是POD：
template <class T>
struct Foo
{
Foo()
{ }
explicit Foo(T* obj) : m_data(obj)
{ }
T* m_data;
};
但是，使用GCC 4.6并使用-std=c++0x标志进行编译，如果我说：
std::cout << std::boolalpha << std::is_pod<Foo<int>>::value << std::endl;
它的产出
浏览 4提问于2013-01-27得票数 7
回答已采纳
1回答
我使用Visual，并且注意到不支持不受限制的联合。我提出了一个vec4结构，最基本的是：
template<class T>
struct vec4
{
T x, y, z, w;
vec4() :x(0), y(0), z(0), w(0) {}
vec4(T x, T y, T z, T w) :x(x), y(y), z(z), w(w) {}
vec4(const vec4& v) :x(v.x), y(v.y), z(v.z), w(v.w) {}
};
所以重点是我不想写vec2i (整数) vec2d (双)等等.分开。然后
浏览 9提问于2015-04-06得票数 1
回答已采纳
1回答
据称，GCC 4.9支持原子shared_ptr操作。
使用GCC 4.9.2，我可以编写一个使用原子shared_ptr的程序。-mcx16标志是必需的，因为GCC在x86_64上的实现显然需要cmpxchg16b，这是有意义的，因为我假设对shared_ptr的原子操作需要同时原子地更新指针本身和引用计数。
但是，当我尝试实际使用原子shared_ptr库时，它的行为并不像我所期望的那样。所以，要么我用得不好，要么GCC的实施有缺陷。大多数时候，我会有99%的信心，我只是做错了，但由于这是一个相对较新的功能，因为行为似乎如此怪异，我只有大约50%的信心，这是我的错在这个例子。
下面是一个简
浏览 3提问于2016-05-12得票数 2
回答已采纳
我确实认识到is_pod是memcpy-able的一个充分条件，但是has_trivial_destructor也足够满足这个目的吗？如果没有，为什么？
浏览 4提问于2012-08-16得票数 10
回答已采纳
C++有一个小规模的结构调用约定优化，编译器在函数参数中传递一个小型结构的效率与传递原始类型(例如通过寄存器)的效率一样高。例如：
class MyInt { int n; public: MyInt(int x) : n(x){} };
void foo(int);
void foo(MyInt);
void bar1() { foo(1); }
void bar2() { foo(MyInt(1)); }
bar1()和bar2()生成几乎相同的汇编代码，但分别调用foo(int)和foo(MyInt)。特别是在x86_64上，它看起来像是：
mov edi, 1
浏览 4提问于2020-09-03得票数 29
令我惊讶的是，这段代码编译时没有错误。当ARC第一次出现的时候，我不认为它曾经是。
class SessionWriter
{
NSString *sessionDir;
...
};
看起来NSString是由ARC在析构函数中释放的。这些文档记录在哪里？
浏览 0提问于2014-05-03得票数 1
使用构建的代码如下：
#include <iostream>
#include <type_traits>
#include <tuple>
int main() {
std::cout << std::is_trivially_copyable<std::tuple<int>>::value << std::endl;
std::cout << std::is_trivially_copyable<std::pair<int, int>>::value &
浏览 4提问于2016-08-05得票数 14
回答已采纳
在我的Linux机器上，sig_atomic_t是一个普通的老式int。ints是否拥有一种特殊的原子质量？
$ gcc -v
Using built-in specs.
Target: x86_64-linux-gnu
...
Thread model: posix
gcc version 4.3.2 (Debian 4.3.2-1.1)
$ echo '#include <signal.h>' | gcc -E - | grep atomic
typedef int __sig_atomic_t;
typedef __sig_atomic_t sig_ato
浏览 0提问于2012-03-08得票数 29
回答已采纳
我一直在查看GCC的std::function实现(在调试过程中得到的，并在切线上运行)。
据我所见，它将小类型存储在本地存储空间中，任何不适合它的内容都通过新的运算符分配。然而，构造函数也会检查__location_invariant元功能，这是一个围绕std::trivially_copyable特性的包装器，如果它不是“位置不变的”，它也会在堆中分配它。
我不完全理解它为什么要这样做，因为我理解::new (storage) T(args)应该提供与new T(args)相同的结果，除了就地构造函数不分配任何内存这一例外。
例如，如果它使用单个引用计数对象来存储“位置不变”类型，而这些类
浏览 1提问于2021-11-04得票数 4
回答已采纳
is_trivially_copy_*和is_trivially_move_*有什么区别？我可以使用memcpy移动构造/赋值is_trivially_move_*类型吗？
浏览 0提问于2018-04-08得票数 3
回答已采纳
我正在尝试获取std::vector<std::any>的大小
当向量是int时，我的函数可以工作，但是我如何让它与std::any一起工作呢？
template<typename T>
size_t vectorsizeof(const typename std::vector<T>& vec)
{
return sizeof(T) * vec.size();
}
std::vector<std::any> args = { (int)3, (bool)true };
auto size = vectorsizeof(args
浏览 0提问于2020-04-14得票数 1
这门课是：
class A {
public:
A() = default;
A(const A&) = delete;
};
微不足道的可复制性？(至少clang似乎这么认为())
特别是，会
A a,b;
std::memcpy(&a, &b, sizeof(A));
调用未定义的行为？
上下文：删除是因为被证明是错误的，加上它的注释树。
浏览 3提问于2015-04-20得票数 31
回答已采纳
这纯粹是假设的，但是我不确定下面的代码是否会根据C++规范导致未定义的行为。我想复制一个对象中的字节，用零覆盖该对象，然后复制回原来的字节。我可以在不引起未定义行为的情况下这样做吗？
示例代码：
NonPODType o;
char bytes[sizeof(o)];
memcpy(bytes, &o, sizeof(o));
memset(&o, 0, sizeof(o));
memcpy(&o, bytes, sizeof(o));
浏览 0提问于2012-06-09得票数 7
回答已采纳
我指的是关于按值传递、按引用传递的语义上的差异和细微差别的各种讨论，例如在这样或维基百科关于这一主题的文章。
我的问题是，为什么这些文章和对话总是只在参数传递和函数调用的上下文中而不是在赋值上下文中讨论逐值、逐引用等问题？
例如，假设如下：
A a1 = new A();
A a2 = a1;
..。为什么不按值复制分配的对象是理所当然的呢？
我不是在问，为什么要让任务的语义“按值”复制对象，这将是一个值得质疑的语言设计决定--我是在问语言规范是否明确地说明了这一点，或者在什么标题下语言设计理论处理了这些决定。
浏览 0提问于2015-02-13得票数 1
回答已采纳
3回答
下面的代码在Visual C++ 2013中编译得很好，但不是在GCC或Clang下编译的。
哪个是对的？
通过隐式转换返回对象时是否需要可访问的复制构造函数？
class Noncopyable
{
Noncopyable(Noncopyable const &);
public:
Noncopyable(int = 0) { }
};
Noncopyable foo() { return 0; }
int main()
{
foo();
return 0;
}
GCC：
error: 'Noncopyable::Noncopyable(c
浏览 1提问于2014-06-16得票数 22
回答已采纳
根据各种消息来源(例如，)，类必须是微不足道的可复制的，才能在memcpy中使用，但我不明白为什么一个微不足道的可复制构造类是不够的。只要我确保析构函数在适当的时候被调用，那么琐碎的可复制类的额外属性(比如一个微不足道的析构函数)就不重要了。
如果在类上使用memcpy (例如，非平凡的析构函数(或移动构造函数))会导致问题，有人能提供示例或解释吗？
浏览 2提问于2016-02-03得票数 4
我不知道下面的发言有什么不对，因为它给了我编辑错误。我们可以不使用原子变量的“自动”吗？
#include <iostream>
#include<future>
#include <atomic>
using namespace std;
int main()
{
atomic<int> value(10);
auto NewValue = value;
}
但是如果我把"auto“替换为"int”，它就能工作了。为什么？
int main()
{
atomic<int> value(10);
浏览 0提问于2018-05-04得票数 1
回答已采纳
1回答
我尝试创建一个包含类的结构，如下所示：
struct my_struct
{
NSString *string;
// more fields
};
令我惊讶的是，Objective-C++在启用ARC的情况下允许这样做。
它将如何管理字符串？
它可以很容易地保留在每个任务中，但释放是问题所在。
它可以在其中添加一个带有release的析构函数，但这将使结构变得非常重要。
它还可以使其不保留或释放，但要做到这一点，应该有unsafe_unretained。
根据我的观察，在使用它时没有崩溃，但我想知道这里到底发生了什么。
浏览 2提问于2012-06-01得票数 11
回答已采纳
考虑一下
struct A1 {
constexpr A1& operator=(const A1&) = default;
~A1() {}
};
struct A2 {
constexpr A2& operator=(const A2&) = default;
~A2() = default;
};
struct A3 {
~A3() = default;
constexpr A3& operator=(const A3&) = default;
};
GCC和MSVC接受这三种结构。Clang
浏览 0提问于2019-03-15得票数 35
回答已采纳
1回答
我想知道以下内容是否泄漏了内存(由标准指定)
...
jmp_buf env;
if(setjmp(env) == 0) {
auto lambda = [&] () {
...
longjmp(env, 1);
};
lambda();
}
哪一个归结为通过引用捕获lambda是否有一个平凡的析构函数(我猜)？
我知道这可能是邪恶的，但仍然必须这样做。
浏览 2提问于2015-04-28得票数 4
回答已采纳
但是，我不明白如何“教”它接受我的类的%s说明符。我的string类是char指针上的一个简单包装器，只有一个成员变量(char * data)，没有虚函数。因此，将其原样传递给类似printf的函数来代替常规的char *是可以的。问题是，在gcc上，静态分析器阻止我这样做，我必须显式地将其强制转换为const char *，以避免警告或错误。
我的cstring看起来像这样：
class cstring
{
cstring() : data(NULL){}
cstring(const char * str) : data(strdup(str)){}
cstring(co
浏览 0提问于2012-12-03得票数 2
回答已采纳
，作者说
只有POD类型可以作为省略号“.”的参数。而std::string不是POD类型。
我把它理解为Passing NON-POD type to Variadic function is undefined behavior。是对的吗？
不过，他说的是C/C++标准吗？我试图在n3242 C++规范中找到它。却找不到。
我想知道我的理解是正确的，这是一个标准。
浏览 3提问于2012-04-10得票数 15
回答已采纳
1回答
我正在研究C++中的多线程，并编写了一个简单的类，其中包含一个私有std::mutex对象，以便在调用成员funcrion时同步：
#include <mutex>
#include <iostream>
class SynchClass
{
public:
SynchClass() {}
void inline SynchronizedInterfaceFunction();
private:
std::mutex mMutex;
};
void inline SynchClass::SynchronizedInterfaceFun
浏览 0提问于2019-04-20得票数 2
回答已采纳
这段代码：
#include <iostream>
#include <vector>
#include <atomic>
struct foo{
std::vector<int> bar;
};
int main(){
std::atomic<foo> theFoo;
theFoo.load().bar.push_back(30);
return 0;
}
当呼叫12线路时，出现错误消息"Access violation“。我做错了什么？我使用的是Visual Studio 2012。
浏览 0提问于2014-02-07得票数 1
在一个充满对象(具有适当行为)和相对较少的非面向对象结构(仅由数据字段和没有方法组成)的C++项目中，我希望防止这些结构的意外误用，在这些结构中，您可能会尝试创建继承它的类。
根据我的理解，由于这些" POD“(普通旧数据)结构没有虚拟析构函数，因此不可能通过POD类型的指针正确删除派生类对象(如果允许创建的话)。
这似乎为C++11 "final“关键字提供了一个很好的用例，该关键字将类或结构标记为不可继承。
然而，我不知道“最终”关键字是否会导致结构变成非POD？
我怀疑标准文档可能已经解决了这个问题，但我没有足够的智慧来筛选非常长的文档来找出答案。欢迎提供任何有用的指示。
浏览 2提问于2015-07-14得票数 7
回答已采纳
的答案是，标量可以转换为_Bool，_Bool的最终整数值将是0或1。
对的公认答案指出，指针是标量。
_Bool**，是将指针隐式转换到的失败，因此，编译器错误？**
例如：
$ cat ./main.c
// main.c
#include <stdbool.h>
int main( int argc, char* argv )
{
int i;
int* p = &i;
bool foo = (bool)p;
bool bar = p;
return 0;
}
失败的编译器(其中一个)：
$ /path/to/mips_fp_le-g
浏览 2提问于2019-12-03得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
