小编Me *_*d I的帖子

我在一周前询问了一个问题,询问如何只在它所采用的类型具有特定成员函数时才能简单地实例化一个类模板.在我的回答中,我得到了一个复杂的解决方案.但后来我试着自己做.我只是想知道这是否足以弄清楚给定类型T是否有一个名为ftake 0参数的void函数.

#include <type_traits>
#include <utility>

template <typename T, typename = void>
struct has_f : std::false_type { };

template <typename T>
struct has_f<
    T,
    decltype(std::declval<T>().f(), void())> : std::true_type { };

template <typename T, typename = typename std::enable_if<has_f<T>::value>::type>
struct A { };

struct B
{
    void f();
};

struct C { };

template class A<B>; // compiles
template class A<C>; // error: no type named ‘type’ 
                     // in ‘struct std::enable_if<false, void>’

如果是这样,为什么其他答案在这个帖子中如此复杂？

我问这个问题是为了减轻我对以下程序的困惑.我知道在某些上下文中使用数组会使数组衰减为指向其第一个元素的单个指针.我有一个函数,通过指针返回此数组(使用此函数创建new[]).数组是否会衰减,导致指针只指向第一个元素？这是一个例子:

int *foo() {
    int *t = new int[10];

    return t;
}

int main() {
    int *p = foo();
}

这就是混乱的地方.我不知道是p指向第一个元素还是指向整个数组.所以我有以下问题:

• 通过指针返回数组会导致它的衰减(并因此导致内存泄漏)？
• 是否p指向数组的第一个元素？
• 如果以上两个是真的,使用delete[]on p会导致未定义的行为吗？

我希望这些问题能得到解答,这样我才能完全理解这个程序.谢谢.

在尝试自己创建一个std::get<N>(std::tuple)方法后,我不太确定它是如何由编译器实现的.我知道std::tuple有这样的构造函数,

tuple(Args&&... args);

但到底args...分配给了什么？我认为这对于知道如何std::get工作是有用的,因为需要将参数放在某处以便访问它们...

在下面的程序中,两个函数调用都打印"非整数过载",即使我有一个enable_if声明只将函数限制为整数容器类型.这是为什么？

#include <iostream>
#include <vector>
#include <type_traits>

template<bool B, typename V = void>
using enable_if = typename std::enable_if<B, V>::type;

template<typename ForwardIt>
auto f(ForwardIt first, ForwardIt)
    -> enable_if<std::is_integral<decltype(*first)>{}>
{
    std::cout << "Integral container type" << std::endl;
}

template<typename ForwardIt>
void f(ForwardIt, ForwardIt)
{
    std::cout << "Non-integral container type" << std::endl;
}

int main()
{
    struct X { };

    std::vector<int> iv;
    std::vector<X>   xv;

    f(iv.begin(), iv.end()); // "Non-integral container type"
    f(xv.begin(), xv.end()); // "Non-integral container type"
}

我甚至尝试过使用enable_if<!std::is_integral<...>>第二次超载,但无济于事.

我想知道为什么我在打印这个函数时总是得到 1 的输出。这是代码：

#include <iostream>
using namespace std;

int main() {
    int x(int());
    cout << x; // 1
}

它总是打印出一个。为什么？我期望它输出 0，因为整数默认为 0。那么为什么是 1？

string array[] = "";

我怎么能分配一个const char*数组？这是一样的:

string array[] = {""};

?? 这对我来说很有意义.但是,这仍然不起作用

int array[] = 5;

那么它们之间的区别在于它对int数组不起作用？

我正在尝试使用运算符转换为B*,但它不起作用.为什么？谢谢.

struct B;

struct A {
    A() = default;

    operator (B *)() {
        return new B();
    }
};

struct B { B() = default; };

int main() {

    A a;

    B *b = a;

}

我收到错误: cannot convert 'A' to 'B*' in initialization

我有以下程序来计算数组的"部分和".例如,如果我1, 1, 1, 1通过std::cin我的程序输入连续的整数将结果计算为数组1, 2, 3, 4.

#include <iostream>

int main()
{
    int orig[10], copy[10];
    std::cout << "please enter 10 numbers:" << std::endl;

    for (int i = 0; i < 10; i++)
    {
        std::cin >> orig[i];
    }

    for (int i = 0; i < 10; ++i)
    {
        int sum = 0;
        for (int k = i; k >= 0; --k)
        {
            sum += orig[k];
        }
        copy[i] = sum;
    }

    std::cout << "the ascending order …

我应该什么时候回来T const&？如果我不打算修改对象,我看不出它与按值返回有什么不同.并且通过const引用返回真的只意味着没有复制.所以什么时候返回T const&有用.

假设我有一个像这样声明的数组:

int *p = new int[size];

而p当然会点的第一个元素的地址.但由于一个字节是存储器的最小可寻址单位,p实际上是指向数组第一个元素的前4个字节的第一个字节吗？