小编Nat*_*ica的帖子

我的代码中有两个枚举:

enum Month {January, February, March, April, May, June, July,
        August, September, October, November, December};
enum ShortMonth {Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec};

May 是两个枚举中的常见元素,因此编译器说:

调查员的重新声明' May'.

为什么这么说呢？我怎么能绕过这个呢？

我见过多次std::string::operator[]不做任何边界检查.甚至string :: at和string :: operator []之间有什么区别？,在2013年询问,答案说operator[]不做任何边界检查.

我的问题是,如果我在[string.access]中查看标准(在本例中为草案N3797)

const_reference operator[](size_type pos) const;
reference operator[](size_type pos);

Run Code Online (Sandbox Code Playgroud)

1. 要求: pos <= size().
2. 返回: *(begin() + pos) if pos < size().否则,返回对charT具有value 的类型对象的引用charT(),其中修改对象会导致未定义的行为.
3. 投掷:没什么.
4. 复杂性:恒定时间.

这使我相信operator[]必须进行某种边界检查以确定它是否需要返回字符串的元素或默认值charT.这个假设是否正确,operator[]现在需要进行边界检查？

据我所知,async在另一个线程/进程/核心中执行一个函数并且不阻塞主线程,但总是这样吗？

我有以下代码:

async(launch::async,[]()
{
    Sleep(1000);
    puts("async");
});
puts("main");

它打印async main,这是否意味着主线程等待直到async完成？

如果我改为以下:

auto f = async(launch::async,[]() // add "auto f = "
{
    Sleep(1000);
    puts("async");
});
puts("main");

它打印main async.这使得看起来主要不等待async完成.

来自cppreference.com的报价:

添加模板特化

允许为任何标准库类添加模板特化(从C++ 20开始)| 模板到命名空间std只有当声明依赖于至少一个程序定义的类型并且特化满足原始模板的所有要求时,除非禁止这样的特化.

是否意味着,从C++ 20开始,将std不再允许将函数模板的特化添加到用户定义类型的命名空间中？如果是这样,它意味着许多现有代码可能会破坏,不是吗？(在我看来,这是一种"激进"的改变.)此外,它会向这些代码注入未定义的行为,这不会触发编译错误(警告有希望).

在shell脚本中,如何通过特定名称查找文件,然后导航到该目录以对其进行进一步操作？

从这里开始,我将把文件复制到另一个目录(但是我可以将其添加到上下文中.)

我对C++很新,一直在避免使用指针.从我在网上看到的,我不能返回一个数组,但我可以返回一个指向它的指针.我做了一个小代码来测试它,并想知道这是否是正常/正确的方法:

#include <iostream>
using namespace std;

int* test (int in[5]) {
    int* out = in;
    return out;
}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* pArr = test(arr);
    for (int i = 0; i < 5; i++) cout<<pArr[i]<<endl;
    cout<<endl;
    return 0;
}

编辑:这似乎并不好.我该怎么改写呢？

int* test (int a[5], int b[5]) {
    int c[5];
    for (int i = 0; i < 5; i++) c[i] = a[i]+b[i];
    int* out = c;
    return out;
}

我无法理解为什么以下复制初始化无法编译:

#include <memory>

struct base{};
struct derived : base{};

struct test
{
    test(std::unique_ptr<base>){}
};

int main()
{
    auto pd = std::make_unique<derived>();
    //test t(std::move(pd)); // this works;
    test t = std::move(pd); // this doesn't
}

A unique_ptr<derived>可以移入a unique_ptr<base>,那么为什么第二个语句有效但最后一个没有？执行复制初始化时是否不考虑非显式构造函数？

gcc-8.2.0的错误是:

conversion from 'std::remove_reference<std::unique_ptr<derived, std::default_delete<derived> >&>::type' 
{aka 'std::unique_ptr<derived, std::default_delete<derived> >'} to non-scalar type 'test' requested

从clang-7.0.0开始

candidate constructor not viable: no known conversion from 'unique_ptr<derived, default_delete<derived>>' 
to 'unique_ptr<base, default_delete<base>>' for 1st argument

现场代码可在此处获得.

这个错误信息是什么意思？

error: call of overloaded ‘setval(int)’ is ambiguous
huge.cpp:18: note: candidates are: void huge::setval(unsigned int)
huge.cpp:28: note:                 void huge::setval(const char*)

我的代码看起来像这样:

#include <iostream>
#define BYTES 8
using namespace std ;

class huge {
private:
    unsigned char data[BYTES];
public:
    void setval(unsigned int);
    void setval(const char *);  
};

void huge::setval(unsigned int t) {
    for(int i = 0; i< BYTES ; i++) {
        data[i] = t;
        t = t >> 1;
    }
}

void huge::setval(const char *s) {
    for(int i = 0; i< …

动机:

几乎是为了好玩,我试图编写一个函数重载,可以分辨参数是固定大小的数组还是指针.

double const  d[] = {1.,2.,3.};
double a;
double const* p = &a;
f(d); // call array version
f(p); // call pointer version

我发现这特别困难,因为众所周知的事实是数组比指针更快地衰减到指针.一种天真的方法就是写作

void f(double const* c){...}
template<size_t N> void f(double const(&a)[N]){...}

不幸的是,这不起作用.因为在最好的情况下,编译器确定f(d)上面的数组调用是不明确的.

部分解决方案:

我尝试了很多东西,我能得到的最接近的是以下具体代码.另请注意,在此示例代码中我使用的是char代替double,但最后它非常相似.

首先,我必须使用SFINAE来禁用函数指针版本中的转换(从数组ref到ptr).其次,我不得不为所有可能的数组大小(手动)重载.

[可编码]

#include<type_traits> // for enable_if (use boost enable_if in C++98)
#include<iostream>
template<class Char, typename = typename std::enable_if<std::is_same<Char, char>::value>::type>
void f(Char const* dptr){std::cout << "ptr" << std::endl;} // preferred it seems

void f(char const (&darr)[0] ){std::cout << …

POD struct可以在C++ 11中进行零初始化,如下所示:

SomeStruct s{};

但是,如果我已经有一个struct的实例并且我想将它重新初始化为零,我该怎么办？以下似乎有效:

s = {};

有人能指出相关的标准吗？我假设这是发生的事情:

1. 创建一个新的零初始化实例.
2. 新实例将分配给现有实例,从而调用隐式赋值运算符.