小编Bat*_*eba的帖子

C++标准说"=","()","[]"应该是非静态成员函数.

为什么用这种方式指定？为什么我们需要以这种方式定义标准？

Netbeans IDE擅长发现可能给您带来麻烦的代码.为什么没有发出警告

public class Base
{
    Base(...)
    {
        ...;
    }

    public void foo()
    {
        ...;
    }
}

public class Child extends Base
{
    Child(...)
    {
        super(...);
        foo();
    }
}

鉴于我在子构造函数中调用基类函数foo()？当然,这是完全合法的,因为基础对象是由foo()调用点构造的,但是foo()隐式地是一个虚方法,所以我真的希望得到一个警告,除非foo()被标记为final.

我认为如果从未标记为final的子类构造函数调用任何基类函数,IDE应该发出警告.

我的代码中有以下行

signed int test_case= -2147483648;

这会产生错误:

C4146一元减运算符应用于无符号类型,结果仍未签名

但这仍然是有符号整数类型的数据范围:

__int32 signed,signed int,int -2,147,483,648 to 2,147,483,647

奇怪的是把它分配为signed long会给出同样的错误,即

signed long test_case= -2147483648;

以下更改编译正常:

signed int test_case= -2147483647;

signed int test_case= 2147483649;

signed long test_case= -214748364800;

• 有没有人用Visual Studio 2015编译器看到这个问题？
• 它是如何定义数据类型的？
• 如何检查范围？
• 为什么它似乎忽略了"签名"任务？

谢谢

C++中是否有任何STL函数允许我在数组中查找重复项的所有索引？

例如:

int array[] = {1,1,2,3,4};

应该返回0,1

我正在display()为容器类型创建一个方便的函数模板.最后一个元素的输出与其余元素不同,因此我检查何时myIterator != --cont.cend();.这适用于std::vector,但不适用std::array.为什么？

这是一个MWE(不是我的实际代码):

std::vector<double> vec({1,2});
std::array<double, 2> arr({{1,2}});
auto vecIt = --vec.end(); // OK
auto arrIt = --arr.end(); // error: lvalue required as decrement operand

考虑以下C++ 11应用程序:

A.cpp:

template<typename T>
struct Shape {
    T x;
    T area() const { return x*x; }
};

int testA() {
    return Shape<int>{2}.area();
}

B.cpp:

template<typename T, typename U = T>
struct Shape {
    T x;
    U y;
    U area() const { return x*y; }
};
int testB() {
    return Shape<int,short>{3,4}.area();
}

Main.cpp的:

int testA();
int testB();
int main() {
   return testA() + testB();
}

虽然它编译(只要A和B是在单独的TU),它看起来不正确,和我有麻烦弄清楚为什么.

因此,我的问题:这是否违反ODR,超载,或任何其他规则,如果是这样,什么部分标准受到侵犯,为什么？

以下代码

#include <iostream>
#include <string>
int main()
{
    std::string s = "abc";
    for (char c : s)
        std::cout << (int) c << " ";
}

打印“97 98 99”。

以下代码

#include <iostream>
int main()
{
    for (char c : "abc")
        std::cout << (int) c << " ";
}

打印“97 98 99 0”。

第二个代码中额外的 0 来自哪里？

我有界面:

interface Identifable<T extends Serializable> {
      T getID();
}

和实现这个的类:

public class Cat implements Identifable<Long> {
       public Long getID(){...};
}

一切正常.至今.现在我想创建GenericDAO,为什么我不能创建它？:

public abstract GenericDAO<T extends Identifable<S>> {
    T getByID(S id);
}

我只能声明我的GenericDAO:

public abstract GenericDAO<T extends Identifable, S> {
  T getById(S id);
}

完整的课程:

public CatDAO extends GenericDAO<Cat, Long> {
      Cat getById(Long id);
}

但我觉得它没用,因为我重复信息.我已经声明,Cat实现了Identifable <Long>,为什么我必须声明GenericDAO <Cat,Long>,而不仅仅是GenericDAO <Cat>？

我有一个const std::map<std::string, std::vector<double>>成员变量和一个函数const std::vector* foo().我希望这个函数有时会返回一个指向这个地图元素的指针.但是我担心地图可能会重新平衡 - 即使在std::map标记的函数中const- 也会使返回的指针无效.我知道任何后续的地图修改都会使我的指针无效,但这不会发生,因为我已经标记了成员变量const.

我不能像往常一样返回参考,foo需要返回nullptr.

我在做什么安全吗？

请考虑以下代码:

#include <iostream>
#include <string>

using namespace std;

// helpers
void disp1(string s, int i, void* p) { cout << s << " constructed with " << i << " @ " << p << "\n"; }
void disp2(string s, void* p)        { cout << s << " @ " << p << "\n"; }

// class hierarchy:
//
//      A   A
//      |   |
//      B   C
//       \ /
//        D
//
struct A        { A() { disp1("A", …