小编Dar*_*bik的帖子

我知道llvm可以用来将c ++转换成c代码.我想知道是否clang可以做同样的事情(看来clang是从中衍生出来的llvm).

那么我可以用clangc ++代码转换成c代码吗？

如果你想知道我为什么要这样做,这是我的场景:

PIC是一家微控制器制造商,它不生产c ++编译器,但确实为其大多数产品制作了c编译器.我想用c ++编写,然后作为构建过程的一部分,将c ++代码转换为临时c文件,然后将其输入PIC编译器,并且我已经为PIC micro编写了c ++代码.

假设我有一个班级:

class MyClass{
  char array[12];
  public:
  MyClass(const char* arr) {
    for (int x = 0; x < 12; x++){
      array[x] = arr[x];
    }
  }
};

是否可以制作MyClass构造函数constexpr.棘手的部分是初始化新阵列....

假设我有一个这样的类:

struct A{
  virtual void someFunc() { }
};

是否可以将虚函数重新分配给另一个函数....这可能是可能的,因为它基本上将一个函数指针存储在类中,以便它可以virtual.

我意识到这样的事情:

void aRandomFunc();
A mya;
mya.someFunc = &aRandomFunc;

可能是不可能的,因为成员函数将this指针作为隐式参数.

但是有可能将成员函数重新分配给另一个成员函数吗？

好的,我有这个代码:

struct Mine{
    template<typename T>
    Mine(T&& x){
    }
};
void nFoo(int&& x){
}
void sFoo(Mine x){
}

将nFoo需要一个int&&直接,而sFoo做一些finagling来获得同样的效果.

考虑以下代码:

nFoo(12); //Works

int x = 0;
nFoo(x);  //Cannot bind int (lvalue) to int&&

sFoo(12); //Works
sFoo(x);  //Works

为什么int&&有时允许从lvalues 绑定,有时不允许绑定？

如果我将这个c ++程序插入clang(版本3.7)

///*
#include "stdio.h"
#include "stdint.h"
//extern int printf(const unsigned char*, ...);


extern "C" void __cxa_pure_virtual() { }

struct A
{
    virtual void foo() = 0;
};

struct B : A
{
    uint32_t x;
    B(int x) : x(x) { }
    virtual void foo()
    {
        printf("This is a test %d\n", x);
    }
};
//*/
uint64_t thing = 0;
float other = 10.0f;
B b(12345);
int main()
{

    thing++;
    A* a = &b;
    other *= 3.14159f;
    a->foo();
}

并编译 …

我正在构建一个模型铁路道口信号,正在研究微控制器代码以使其正常工作.我遇到了一个让我质疑我的方法论的问题.

我正在阅读RFID标签(每辆车内都有一个),一旦列车触发进入过道门区域,并将标签号码放入一个阵列中.问题是阵列很可能总是需要重新调整大小,因为不是每辆列车都有相同数量的汽车,因此RFID标签的数量相同.我需要捕获最后一个汽车标签,因为我需要从出口区RFID阅读器监控该标签,所以我知道何时关闭大门并关闭闪光灯.此外,我可以计算汽车,因为发现了新标签,并且刚刚匹配出口区域中的计数,因此不需要阵列.

除了和数组之外还有更有效的方法吗？我是一个C#家伙,所以不熟悉如何在C++中处理,使用指针和随附的所有内容.

另一个想法是放弃数组,只需更换每个标签的标签识别变量阅读,思考过去的汽车标签将在变量所有的时间,并匹配入口和出口的汽车数量,这可能是最简单的解决方案.

关于最佳方法的想法？

当您在 PDP 字节序中进行位移时，此操作是否比在小字节序或大字节序系统上花费的时间稍长一些？

我问这个问题的原因是因为对于计算机来说，似乎很难在一个班次中向各个方向传输位。

我无法以任何方式测试这一点，因为我无法访问 PDP 字节序机器。=(

我想覆盖运算符new以获得此签名:

void* operator new(size_t bytes, MemoryManager* man);

这堂课MemoryManager看起来像这样:

struct MemoryManager
{
  virtual void* Allocate(size_t bytes) = 0;
  virtual void Deallocate(void* ptr) = 0;
};

现在我想做的是让重载new函数分配比要求更多的内存.然后在最后几个字节中它将存储一个指向该MemoryManager对象的指针,以便它知道在我的自定义delete运算符中使用什么函数.所以看起来像这样分配:

 __________
|          |   _
|__________|    |
|          |    |
|__________|    |
|          |    | <---- Bytes requested for object
|__________|    |
|          |    |
|__________|    |
|          |   _|
|__________|   
|          |   _ 
|__________|    | <---- Pointer to MemoryManager
|          |   _|
|__________|   

现在我真正的问题是:这样做会导致未定义的行为吗？一些可能有问题的事情:

• new …

所以我有几个函数,我得到一个神奇的函数对象,它提供了重载解析:

void foo1();
void foo2(int);


auto foo_ptr = boost::hana::overload(foo1,foo2);
//Later
foo_ptr(12);  //Both Valid (Yeah!)
foo_ptr();

但是,当我做这样的事情时,问题出现了:

using ptr_t = decltype(foo_ptr);

struct mine
{
    ptr_t ptr;
    mine(ptr_t ptr) : ptr(ptr){}
};


mine m(foo_ptr);

当我尝试编译这段代码时,我得到了error: no matching function for call to 'boost::hana::overload_t<void (*)(int)>::overload_t()'.

看看Godbolt .....

现在我的问题是:

我是否允许复制这些重载对象(hana的文档没有说明这种或那种方式),如果是这样的话,为什么当我把它作为成员放在一个类中时它会失败？

我的问题是这样的：

假设类型T是可复制的。...可以在不调用构造函数的情况下“创建”该类型的实例。

#include <type_traits>
#include <cstring>

using T = int; // T can be any trivially copyable type


T create(const T& other)
{
    std::aligned_storage_t<sizeof(T),alignof(T)> my_T;

    std::memcpy(&my_T,&other,sizeof(T));

    return *reinterpret_cast<T*>(&my_T);
}

这是已定义的行为，还是只能复制到T类型的现有对象中？

我相当肯定uint8_t从另一个中减去一个应该导致另一个无符号数,但我的一些结果让我感到困惑.

  uint8_t a = 2;
  uint8_t b = 1;
  uint8_t c = -a;
  long d = b - a;
  long e = b + c;

当我获得d它产生的价值时-1,e正如我所期望的那样255.这是gcc我正在使用的版本的错误.....对吗？

作为参考,我正在使用arm-none-eabi-g++编译器MSP-432.

看着这似乎表明gcc这里似乎犯了同样的错误.

看看这个问题似乎看起来像神弩和手臂gcc是错误的.

这里发生了什么？

c ++中的操作!=和=!操作有什么区别？

我试着谷歌搜索答案,但似乎搜索引擎不接受一些文本,如!=或=!

我也知道差异的逻辑是什么,但我想不出一个实际的例子.我的意思是假设我有两个参数A和B在什么条件下A =!B将是真的但A!= B将是假的

if(A!=B) return true;
if(A=!B) return false;

我真的找不到任何搜索引擎的答案,似乎在任何文档中都没有提到.

是否有可能编写一个通用基类,所有其他类(除了它)公开并实际上继承？(gcc有解决方法吗？).最好不要明确地继承...因为我希望标准库的东西也从这里继承....这是明智的做法吗？

如果你投票,请解释原因(我相信这是一个合法的问题,即使它是一个愚蠢的事情,它可能是,但这是问题的一部分)