javascript

git

java

python

git-remote

c++

github

django

c#

reactjs

generator

coroutine

spring-mvc

reflection

javascript-objects

html5

analytics

node.js

performance

branch-prediction

为什么派生的模板类不能访问基本模板类的标识符?

考虑:

template <typename T>
class Base
{
    public:
        static const bool ZEROFILL = true;
        static const bool NO_ZEROFILL = false;
}

template <typename T>
class Derived : public Base<T>
{
    public: 
        Derived( bool initZero = NO_ZEROFILL );    // NO_ZEROFILL is not visible
        ~Derived();
}

我无法使用GCC g ++ 3.4.4(cygwin)进行编译。

在将它们转换为类模板之前,它们是非泛型的,派生类能够查看基类的静态成员。 C ++规范的要求中是否存在这种可见性损失,还是我需要采用语法更改?

我了解到Base<T>的每个实例都将具有其自己的静态成员“ ZEROFILL”和“ NO_ZEROFILL”,即Base<float>::ZEROFILLBase<double>::ZEROFILL是不同的变量,但我并不在乎; 该常量用于代码的可读性。 我想使用静态常量,因为就名称冲突而言,这比使用宏或全局方法更安全。

trans by 2020-08-12T04:52:30Z

我如何防止通过'new'运算符分配一个类? (我想确保RAII类始终分配在堆栈上。)

我想确保RAII类始终分配在堆栈上。

如何防止通过“新”运算符分配类?

trans by 2020-07-23T18:08:16Z

设计模式-C ++程序员应该使用哪些C ++习惯用法?

C ++程序员应该知道哪些C ++习惯用法?

用C ++习惯用语,是指仅适用于C ++或比大多数其他语言更适用于C ++的设计模式或做某些事情的方式。

为什么要使用成语?成语有什么作用?

trans by 2020-06-23T02:17:22Z

我应该在C ++程序中包含<xxxx.h>还是<cxxxx>吗?

  • 我应该在C ++程序stdio.hcstdio中包含什么? 为什么?
  • 为什么两个提供相同功能的头文件?
  • 标准对此有何说法?
  • 我应该如何包括其他此类标头?是否有应遵循的基本规则?
trans by 2020-02-08T07:28:15Z

防止对象的堆栈分配而仅允许使用“新”实例化它?

是否可以防止对象的堆栈分配,而只允许在堆上使用“ new”来初始化它?

trans by 2020-01-29T02:21:00Z

编译器为一个类创建的所有成员函数是什么? 这是否一直发生?

编译器为一个类创建的所有成员函数是什么? 这是否一直发生? 像破坏者一样。我担心的是是否为所有类创建了它,为什么需要默认构造函数?

trans by 2019-11-04T18:08:52Z

为什么我们实际上需要C ++中的私有或受保护的继承?

在C ++中,我想不出要从A继承private / protected的情况。基类:

class Base;
class Derived1 : private Base;
class Derived2 : protected Base;

真的有用吗?

trans by 2019-10-27T07:25:01Z

在多线程C ++ 11程序中未处理异常时会发生什么?

如果我有一个C ++ 11程序运行两个线程,并且其中一个抛出未处理的异常,会发生什么? 整个程序会火死吗? 引发异常的线程是否会单独死亡(如果是,在这种情况下我可以获取异常)吗? 还有其他东西吗?

trans by 2019-10-15T06:49:27Z

异常-C ++中的对象销毁

在C ++中确切地销毁对象是什么意思? 因为没有垃圾收集器,我是否必须手动销毁它们? 异常如何发挥作用?

(注意:这是Stack Overflow的C ++ FAQ的一个条目。如果您想批评以这种形式提供FAQ的想法,则可以在开始所有这些操作的meta上进行发布。) 该问题在C ++聊天室中进行监控,C ++聊天室首先出现了FAQ想法,因此,提出这个想法的人很可能会读懂您的答案。)

trans by 2019-10-04T07:49:32Z

c ++-“假设”规则到底是什么?

如标题所示,

“假设”规则到底是什么?

一个典型的答案是:

允许任何和所有代码转换而不会改变程序可观察行为的规则

我们会不时地从某些实现中获取归因于该规则的行为。 很多次是错误的。 所以,这到底是什么规则。 该标准没有清楚地将此规则作为一个部分或段落提及,那么该规则的作用范围到底是什么呢? 对我来说,这似乎是一个灰色区域,该标准未对其进行详细定义。 有人可以引用标准的参考文献来详细说明细节吗?

注意:将其标记为C和C ++,因为它与两种语言都相关。

trans by 2019-09-22T21:37:20Z

C ++中循环移位(旋转)操作的最佳实践

左和右移位运算符(<<和>>)已经在C ++中可用。但是,我找不到如何执行循环移位或旋转操作的方法。

如何执行“向左旋转”和“向右旋转”之类的操作?

在这里向右旋转两次

Initial --> 1000 0011 0100 0010

应导致:

Final   --> 1010 0000 1101 0000

一个例子会有所帮助。

(编者注:如果C的旋转计数为零,或者编译为多个旋转机械指令,则许多用C表示旋转的常见方法都会遭受不确定的行为。此问题的答案应记录最佳实践。)

trans by 2019-09-21T00:34:09Z

c ++ - 函数指针的重点是什么?

我很难看到函数指针的实用程序。 我想它在某些情况下可能是有用的(毕竟它们存在),但我想不出使用函数指针更好或不可避免的情况。

你能举出一些好用函数指针的例子(在C或C ++中)吗?

trans by 2019-09-16T20:19:49Z

c ++ - 派生类中具有相同名称但签名不同的函数

我有一个具有相同名称的函数,但在基类和派生类中具有不同的签名。 当我尝试在继承自派生的另一个类中使用基类的函数时,我收到一个错误。 请参阅以下代码:

class A
{
    public:
    void foo(string s){};
};

class B : public A
{
    public:
    int foo(int i){};
};

class C : public B
{
    public:
    void bar()
    {
        string s;
        foo(s);
    }
};

我从gcc编译器收到以下错误:

In member function `void C::bar()': no matching function for call to `C::foo(std::string&)' candidates are: int B::foo(int)

如果我从类B中删除int foo(int i){};,或者如果我从foo1重命名它,一切正常。

这有什么问题?

trans by 2019-09-14T15:40:43Z

c ++ - 除了运算符优先级之外,什么时候额外的括号有效?

C ++中的括号用于许多地方:例如 在函数调用和分组表达式中覆盖运算符优先级。 除了非法的额外括号(例如函数调用参数列表周围)之外,C ++的一般但非绝对规则是额外的括号永远不会受到伤害:

5.1主要表达式[expr.prim]

5.1.1一般[expr.prim.general]

6带括号的表达式是一个主要表达式,其类型和   值与所附表达式的值相同。 存在   括号不会影响表达式是否为左值。   带括号的表达式可以在完全相同的上下文中使用   可以使用封闭表达式的那些,并使用相同的表达式   意义,除非另有说明。

问题:在哪些上下文中,额外的括号会改变C ++程序的含义,而不是覆盖基本的运算符优先级?

注意:我认为指针到成员语法的限制为&qualified-id而没有括号超出范围,因为它限制语法而不是允许两个具有不同含义的语法。 同样,在预处理程序宏定义中使用括号也可以防止不必要的运算符优先级。

trans by 2019-09-11T15:43:03Z

为什么一个简单的“Hello World”风格的程序不能用Turbo C ++编译?

我已经开始为我的编程课学习C ++了。 我已经下载了这个“Hello World”程序:

#include <iostream>
using namespace std;

int main() 
{
    cout << "Hello, World!";
    return 0;
}

但是Turbo C ++抱怨道:

Error D:\HELLO.CPP 1: Unable to open include file 'IOSTREAM'
Error D:\HELLO.CPP 2: Declaration syntax error
Error D:\HELLO.CPP 6: Undefined symbol 'cout'

这个非常简单的程序出了什么问题? 我该如何纠正这些错误?

trans by 2019-08-07T10:38:43Z

c ++ - 什么是透明比较器?

在C ++ 14中,关联容器似乎已经从C ++ 11改变了 - [associative.reqmts] / 13说:

除非存在类型Compare::is_transparent,否则成员函数模板std::set,Key, Compare = std::less<Key>, ...,find,countequal_range不应参与重载决策。

使比较器“透明”的目的是什么?

C ++ 14还提供了这样的库模板:

template <class T = void> struct less {
    constexpr bool operator()(const T& x, const T& y) const;
    typedef T first_argument_type;
    typedef T second_argument_type;
    typedef bool result_type;
};

template <> struct less<void> {
    template <class T, class U> auto operator()(T&& t, U&& u) const
    -> decltype(std::forward<T>(t) < std::forward<U>(u));
    typedef *unspecified* is_transparent;
};

例如,std::set没有透明比较器,但Key, Compare = std::less<Key>, ...会有一个。

这解决了什么问题,这会改变标准容器的工作方式吗? 例如,模板参数std::set仍然是Key, Compare = std::less<Key>, ...,那么默认设置是否会丢失其findcount等成员?

trans by 2019-08-07T07:13:22Z

为什么标题中的C ++内联函数?

注意:这不是关于如何使用内联函数或它们如何工作的问题,更多的是为什么它们按照它们的方式完成。

类成员函数的声明不需要将函数定义为inline,它只是函数的实际实现。 例如,在头文件中:

struct foo{
    void bar(); // no need to define this as inline
}

那么为什么类函数的内联实现必须在头文件中呢? 为什么我不能把内联函数放到.cpp文件中? 如果我在哪里尝试将内联定义放在.cpp文件中,我会得到一个错误:

error LNK2019: unresolved external symbol 
"public: void __thiscall foo::bar(void)"
(?bar@foo@@QAEXXZ) referenced in function _main 
1>C:\Users\Me\Documents\Visual Studio 2012\Projects\inline\Debug\inline.exe 
: fatal error LNK1120: 1 unresolved externals
trans by 2019-08-03T17:53:02Z

c ++ - cout << a ++ << a ;?的正确答案是什么?

最近在一次采访中有一个以下客观类型的问题。

int a = 0;
cout << a++ << a;

回答:

一个。10
湾01
C。 未定义的行为

我回答了选择b,即输出为“01”。

但令我惊讶的是,一位采访者告诉我,正确的答案是选项c:undefined。

现在,我确实知道C ++中序列点的概念。 以下语句的行为未定义:

int i = 0;
i += i++ + i++;

但根据我对声明cout << a++ << a的理解,ostream.operator<<()将被调用两次,首先是ostream.operator<<(a++),后来是ostream.operator<<(a)

我还检查了VS2010编译器的结果,其输出也是'01'。

trans by 2019-07-31T17:03:22Z

c ++ - 启用优化的不同浮点结果 - 编译器错误?

以下代码适用于Visual Studio 2008,有无优化。 但它只适用于没有优化的G ++(O0)。

#include <cstdlib>
#include <iostream>
#include <cmath>

double round(double v, double digit)
{
    double pow = std::pow(10.0, digit);
    double t = v * pow;
    //std::cout << "t:" << t << std::endl;
    double r = std::floor(t + 0.5);
    //std::cout << "r:" << r << std::endl;
    return r / pow;
}

int main(int argc, char *argv[])
{
    std::cout << round(4.45, 1) << std::endl;
    std::cout << round(4.55, 1) << std::endl;
}

输出应该是:

4.5
4.6

但g ++优化(O1 - O3)将输出:

4.5
4.5

如果我在t之前添加/fp:fast关键字,它可以工作,那么可能存在某种优化错误吗?

测试g ++ 4.1.2和4.4.4。

以下是ideone的结果:[http://ideone.com/Rz937]

我在g ++上测试的选项很简单:

g++ -O2 round.cpp

更有趣的结果,即使我在Visual Studio 2008上打开/fp:fast选项,结果仍然是正确的。

进一步问题:

我想知道,我应该总是打开/fp:fast选项吗?

因为我测试的g ++版本附带了CentOS / Red Hat Linux 5和CentOS / Redhat 6。

我在这些平台下编译了很多程序,我担心它会在我的程序中引起意外的错误。 调查我的所有C ++代码并使用库是否有这样的问题似乎有点困难。 有什么建议吗?

是否有人对为什么连打开/fp:fast感兴趣,Visual Studio 2008仍然有效? 看起来Visual Studio 2008在这个问题上比g ++更可靠吗?

trans by 2019-07-22T00:57:01Z

c ++ - 如何重载std :: swap()

在排序甚至分配期间,许多标准容器(例如std::liststd::vector)使用std::swap()

但是std::swap()的std实现非常普遍,而且对于自定义类型来说效率很低。

因此,通过使用自定义类型特定实现重载std::swap()可以获得效率。 但是如何实现它以便std容器使用它?

trans by 2019-07-17T16:45:41Z

1 2 3 4 5 下一页 共5页