小编Vit*_*meo的帖子

int main() 
{
    float* ptr;

    {
        float f{10.f};
        ptr = &f;
    }

    *ptr = 13.f;
    // Do more stuff with `*ptr`...
}

它使用/访问有效或未定义的行为*ptr？

我测试了类似于上面示例的情况,并且所有内容似乎都起作用,好像嵌套块中变量的生命周期由于指针而被扩展.

我知道const&(const引用)将延长临时的生命周期.指针是否相同？

我正在尝试使用我在Windows上制作的库来编译项目,使用MinGW 4.8.1 x86.该项目在Linux上编译良好.

Common.hpp包含在其他所有内容之前,并根据当前操作系统定义一些宏.然后包含ConsoleFmt.hpp,它包含一个文件,具体取决于先前定义的宏.

我收到一个错误 - 这是代码和错误消息:

Common.hpp

#if (__linux || __unix || __posix)
    #define SSVU_OS_LINUX
#elif (_WIN64 || _WIN32)
    #define SSVU_OS_WINDOWS
#else
    #define SSVU_OS_UNKNOWN
#endif

ConsoleFmt.hpp

#include "Common.hpp"

#ifdef SSVU_OS_LINUX
    #include "SSVUtils/Core/ConsoleFmt/Internal/ConsoleFmtImplUnix.hpp"
#elif SSVU_OS_WINDOWS
    #include "SSVUtils/Core/ConsoleFmt/Internal/ConsoleFmtImplWin.hpp"
#else
    #include "SSVUtils/Core/ConsoleFmt/Internal/ConsoleFmtImplNull.hpp"
#endif

错误:

错误:#elif没有表达式:

#elif SSVU_OS_WINDOWS

我的代码无效或MinGW中是否有错误？我想我使用#elif得当.

我发现自己经常定义enum如下类型：

struct Foo { }
struct Bar { }
struct Baz { }

enum MyEnum {
    Foo(Foo),
    Bar(Bar),
    Baz(Baz),
}

我发现重复的内容Foo(Foo)不雅且多余。它还使初始化变得多余：

let example = MyEnum::Foo(Foo{ /* ... */ });

我想编写类似以下伪代码的内容：

struct Foo { }
struct Bar { }
struct Baz { }

type_enum MyEnum {
    Foo,
    Bar,
    Baz,
}

let example = MyEnum::Foo{ /* ...anything that `Foo` supports ... */ };

std::variant上面的内容与C++17 中的非常相似。Rust 支持类似的东西吗？

在某些情况下,我可能需要使用相同的行为/代码,其值有时在运行时和编译时是已知的.这会导致代码重复:

template<int TValue> struct CompileTime
{
    int duplicate() { return TValue * 2; }
};

struct RunTime
{
    int value;
    RunTime(int mValue) : value{mValue} { }
    int duplicate() { return value * 2; }
};

int main()
{
    // I need to duplicate a compile-time known value first...
    CompileTime<2>{}.duplicate();

    // And now I need to duplicate a run-time value...
    int value; std::cin >> value;
    RunTime{value}.duplicate();
}

显然这个例子真的很愚蠢,但有什么方法可以避免重复这种行为duplicate()？(但是,需要存储该值.)

理想情况下,我想写:

int main() 
{
    // 2 is known at compile-time, …

我需要帮助,我一直在同一台计算机上执行此操作,这意味着我已经安装了boost库,并且基于之前的代码,但这次它给了我错误:/tmp/ccpAYzPw.o:在函数`main' :

reading_data.cpp:(.text+0x356): undefined reference to `boost::program_options::options_description::m_default_line_length'
reading_data.cpp:(.text+0x361): undefined reference to `boost::program_options::options_description::m_default_line_length'
reading_data.cpp:(.text+0x3a6): undefined reference to `boost::program_options::options_description::options_description(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unsigned int, unsigned int)'
reading_data.cpp:(.text+0x3d3): undefined reference to `boost::program_options::options_description::add_options()'
collect2: error: ld returned 1 exit status
<builtin>: recipe for target 'reading_data' failed

我花了差不多2个小时看看发生了什么？但我无法理解为什么,所以我需要你的帮助.

这是我的代码,非常感谢你.

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>      // std::ifstream
#include <boost/program_options.hpp>

int main ()
{
    boost::program_options::options_description desc("Allowed options");

    desc.add_options()
            ("sign"  , program_options::value<string>()  -> default_value("gbm")    ,"name of the input")
            ("week"  , program_options::value<double>()  -> default_value(1930)     ,"number …

template<typename T> char* allocateSomething()
{
    return reinterpret_cast<char*>(std::allocator<T>{}.allocate(1));
}

void deallocateSomething(char* mPtr) { delete mPtr; }

struct TestType { ... };

int main()
{
    char* ptr{allocateSomething<TestType>()};
    deallocateSomething(ptr);   
    return 0;
}

是否可以保证deallocateSomething(ptr)释放所有已分配的字节,即使它typename T在调用时不知道使用的是什么allocateSomething<T>()？

还是有必要模板化deallocateSomething？

编辑:我手动处理对象的构造/销毁.

编辑2:这会正常工作吗？

template<typename T> char* allocateSomething()
{
    return reinterpret_cast<char*>(std::malloc(sizeof(T)));
}

void deallocateSomething(char* mPtr) { std::free(mPtr); }

// ...