小编Ara*_*raK的帖子

我刚问了一个关于访问STL适配器的底层容器的问题.我得到了一个非常有用的答案:

template <class T, class S, class C>
    S& Container(priority_queue<T, S, C>& q) {
        struct HackedQueue : private priority_queue<T, S, C> {
            static S& Container(priority_queue<T, S, C>& q) {
                return q.*&HackedQueue::c;
            }
        };
    return HackedQueue::Container(q);
}

int main()
{
    priority_queue<SomeClass> pq;
    vector<SomeClass> &tasks = Container(pq);
    return 0;
}

不幸的是,我无法理解这一行:

return q.*&HackedQueue::c;

这条线做什么？此外,该行怎么可以访问私有容器priority_queue传递给函数Container？

我想知道为什么C++编译器不会自动为标头生成标头保护？

// Why do I have to write this for every .hpp file I create?!!
#ifndef myheader_hpp__
#define myheader_hpp__
// ...
#endif

我没有遇到我写标题时不需要它们的情况.我看不出相反行为的真实用例,但我很高兴看到一个.有技术难题还是只是历史？!

我想知道如何使用C++全功能指针算法实现垃圾收集器.此外,在像Java这样的语言中,我无法为引用分配文字地址.在C++中它非常灵活.

我相信C#有两个,但C#中的不安全指针又是程序员的责任.

EITD ::伙计们,我问C++指针'他们目前'是否可以在理论上得到GC？

你把它称为插件,插件或以后与原始软件连接的代码,这真的没关系.我很想了解它们是如何工作的,必须对如何设计插件系统进行简单的解释.不幸的是,我从来没有理解过,在我的脑海里仍然存在许多悬而未决的问题.例如,程序如何找到插件？它是如何与它接口的？什么时候软件最好有插件系统？

感谢所有有用的答案.看来我问过于开放的问题,幸运的是我找到了关键词.我喜欢David回答虽然我不是Java人,但他的谈话对我有意义:)

当我读到这个问题的litb回答时,我了解到通过引用传递数组允许我们获得它的大小.我只是玩了一点代码,并尝试通过引用传递一个"函数",并且令人惊讶地(至少对我来说),这段代码编译:

void execute( void (&func)() ) // func is passed by reference!
{
    func();
}

最后一个函数和这个函数之间有什么区别:

void execute( void (*func)() ) // func is passed by pointer!
{
    func();
}

我尝试使用VC2008,它在每种情况下产生不同的输出.奇怪的是,在函数指针的情况下,编译器会更好地优化代码:

void print()
{
    std::cout << "Hello References!";
}
void execute( void (&func)() ) // optimized
{
    func();
}
int main()
{
    00291020  call   print (291000h)
}
=========================================
// In this case, the compiler removes all function calls in the code!
void print() // optimized!
{
    std::cout << …

我已经尝试并烧毁了我的大脑,以理解离散数学中的常规语言及其应用(罗森)的定义,但没有达到理解为什么定义与本书中的定义相同的目标.在页面(789),我正在改写定义:

类型3语法定义为:

w1 --> w2

其中w1是非终端,w2的形式如下:

w2 = aB
w2 = a

其中B是非终端,a是终端.一个特例是当w1是起始符号而w2是lambda(空字符串)时:

w1 = S
S --> lambda

我无法找到两个问题的答案.首先,为什么w2不能成为Ba的形式.其次,为什么拉姆达只允许起始符号只.该书指出,常规语言相当于有限状态自动机,我们可以很容易地看到我们可以为这两种情况构建FSA.我查看了其他资源,这些资源中不存在这些限制.

我只是在学习C++中的元编程基础知识,我觉得很高兴看到其他人如何解决以下问题.另外,看到使用Boost元编程库的解决方案会非常好,因为我认为它们对我来说是一个黑暗的角落.所以问题是,这可以更优雅地重写吗？

假设我们有以下结构:

template <std::size_t size>
struct type_factory
{
  typedef typename type_factory_impl<size>::type type;
};

这个结构应该是typedef type,取决于的值size.type_factory_impl是实施type_factory.用于确定的算法type是:

if(size % bits<unsigned long long>::value == 0)
  typedef unsigned long long type;
else if(size % bits<unsigned long>::value == 0)
  typedef unsigned long type;
else if(size % bits<unsigned int>::value == 0)
  typedef unsigned int type;
else if(size % bits<unsigned short int>::value == 0)
  typedef unsigned short int type;
else if(size % bits<unsigned char>::value == 0)
  typedef …

可以说我们有两个编译单元如下:

// a.cpp
extern int value2;
int value1 = value2 + 10;

// b.cpp
extern int value1;
int value2 = value1 + 10;

当我在VC2010上尝试它时,它首先初始化value1并value2归零.不能全是value1和value2动态初始化,并默认初始化不会对他们适用？

谢谢,

美好的一天,

我的一个朋友正在询问将整数平方根函数转换为元函数.这是原始功能:

unsigned isqrt(unsigned value)
{
    unsigned sq = 1, dlt = 3;
    while(sq<=value)
    {
        sq  += dlt;
        dlt += 2;
    }
    return (dlt>>1) - 1;
}

我使用了一个元版本constexpr,但他说他出于某种原因无法使用新功能:

constexpr std::size_t isqrt_impl
    (std::size_t sq, std::size_t dlt, std::size_t value){
    return sq <= value ?
        isqrt_impl(sq+dlt, dlt+2, value) : (dlt >> 1) - 1;
}

constexpr std::size_t isqrt(std::size_t value){
    return isqrt_impl(1, 3, value);
}

所以我认为将其转换为以递归方式调用它的模板结构应该不难:

template <std::size_t value, std::size_t sq, std::size_t dlt>
struct isqrt_impl{
    static const std::size_t square_root = 
        sq <= …

我的大学即将开始,但我想在剩下的几周内做点什么:)

上学期我上了一门课程programming languages,我想把我的知识变为现实.有什么简单的,优雅的语言可以在初级程序员实施一个解释？

我不介意语言是非常小还是实验性的.