小编Dan*_*aum的帖子

参考什么决定在两个源文件中为同名的类包含哪个类定义？在其中存在故意明确违反单一定义规则的情况,我仍然感到困惑的是,编译器/链接器如何选择一个定义而不是另一个定义是可能的.

(附录基于答案/评论:我要寻找的编译器/连接如何只举一个例子可能.产生如下所示的结果,给定的代码是故意标准的侵犯,因此代码产生不确定的行为)

代码示例是:

// file1.cpp:

#include <iostream>
#include "file2.h"

struct A
{
    A() : a(1) {}
    int a;
};

int main()
{
    // foo() <-- uncomment this line to draw in file2.cpp's use of class A

    A a; // <-- Which version of class A is chosen by the linker?
    std::cout << a.a << std::endl; // <-- Is "1" or "2" output?
}

...

//file2.h:

void foo();

...

// file2.cpp:

#include <iostream>
#include "file2.h" …

我想从基类窗口小部件派生我的所有窗口小部件，该基类窗口小部件会自动在该类的插槽和（很少调用的）信号之间建立信号/插槽连接。

插槽是一种虚拟功能，因此我希望为其实现自定义功能的任何小部件都可以从虚拟插槽功能中派生。在理想的情况下，我的所有小部件都将从带有虚拟插槽的该基类派生，因此默认情况下，我的所有小部件实例都将通过为该对象定义的插槽连接到所需的信号（基类具有默认行为） ）。

我知道Qt中允许使用虚拟插槽。但是，不支持从两个QObject类派生，因此，例如，不允许以下代码：

class MySignaler : public QObject
{
    Q_OBJECT
    public:
        MySignaler : QObject(null_ptr) {}
    signals:
        void MySignal();
}

MySignaler signaler;

class MyBaseWidget: public QObject
{
    Q_OBJECT
    public:
        MyBaseWidget() : QObject(null_ptr)
        {
            connect(&signaler, SIGNAL(MySignal()), this, SLOT(MySlot()));
        }
    public slots:
        virtual void MySlot()
        {
            // Default behavior here
        }
}

// Not allowed!
// Cannot derive from two different QObject-derived base classes.
// How to gain functionality of both QTabWidget and the MyBaseWidget base class?
class MyTabWidget : public QTabWidget, …

关于Java中没有运算符重载这一事实的2年左右的讨论(为什么Java不提供运算符重载？),并且从很多C++年代开始到Java,我想知道是否还有更多运算符重载不是Java语言的一部分的根本原因,至少在赋值的情况下,而不是答案底部附近的最高级别答案(即James Gosling的个人选择).

具体来说,考虑分配.

// C++
#include <iostream>

class MyClass
{
public:
    int x;
    MyClass(const int _x) : x(_x) {}
    MyClass & operator=(const MyClass & rhs) {x=rhs.x; return *this;}
};

int main()
{
    MyClass myObj1(1), myObj2(2);
    MyClass & myRef = myObj1;
    myRef = myObj2;

    std::cout << "myObj1.x = " << myObj1.x << std::endl;
    std::cout << "myObj2.x = " << myObj2.x << std::endl;

    return 0;
}

输出是:

myObj1.x = 2
myObj2.x = 2

但是,在Java中,该行myRef = myObj2(假设myRef前一行中的声明是 …

我已经下载了一个diff文件来修改版本化项目目录中的许多文件(Xerces 2.8).diff文件包含每个"left"文件的完整路径(由 - 符号表示的文件)."右"文件(+符号)包含相对路径.例如:

--- /opt/local/var/macports/build/_opt_local_var_macports_sources_rsync.macports.org_release_ports_textproc_xercesc/work/xerces-c-src_2_8_0/src/xercesc/util/Platforms/MacOS/MacCarbonFile.cpp  2007-08-28 20:44:07.000000000 +0200
+++ src/xercesc/util/Platforms/MacOS/MacCarbonFile.cpp  2009-10-28 19:37:22.000000000 +0100

我想用diff文件更新的项目目录的本地副本当然是在不同的完整路径上.

我无法弄清楚在哪里放置diff文件(或者更确切地说,在我运行时在什么目录中定位自己patch)以及要运行的命令.

因为第二个(+)文件是一个相对路径,我认为将自己定位在我的本地文件系统中的正确位置,以便相对路径正确 - 然后发出命令

patch -i patchfile

... 会工作.它没有(相反,它patch向我提示每个文件的提示,因为它找不到它).

我应该发出什么命令才能使用patch？来合并diff文件？

请考虑以下代码,它const以"嵌套"方式将临时对象绑定到引用:

#include <iostream>

std::string foo()
{
    return "abc";
}

std::string goo()
{
    const std::string & a = foo();
    return a;
}

int main()
{
    // Is a temporary allocated on the heap to support this, even for a moment?
    const std::string & b = goo();
}

我一直试图理解编译器在内存存储方面必须做些什么才能支持这种"嵌套"结构.

我怀疑对于调用foo(),内存分配很简单:std::string当函数foo()退出时,将在堆栈上分配a的存储.

但是,编译器必须做什么来支持所引用的对象的存储b？函数的堆栈goo必须展开并"替换为" b引用的堆栈上的对象,但是为了展开堆栈goo,编译器是否需要在堆上暂时创建对象的副本(在复制之前)它回到不同位置的堆栈)？

或者编译器是否可以完成此构造的要求而不在堆上分配任何存储,即使是暂时的？

或者是它甚至可以将编译器使用相同的存储位置,以由所引用的对象b作为对象由称为a,而不做任何堆栈或在堆上的任何附加配置？

当然,我想不出任何我想要覆盖一元运算&符的原因,但在/sf/answers/317996941/中,海报说明了某些类X:

...除非X做了一些非常愚蠢的事情,比如超载一元并且返回这个

(注意:我认为这个评论指的是&操作员返回this的事实,而不是覆盖&操作员本身的事实.)

正如我想过评论,它发生,我认为"回归这" 究竟该怎样&操作呢-即使是在多重继承的情况下.

鉴于人们可能永远不想覆盖一元运算&符,但是为什么让它返回是愚蠢的this(如果你决定覆盖它)？

我正在修改遗留代码,该代码利用LL硬编码常量的"long long"()数据类型定义,如下所示:

0xFFFFFFFFFFFFFFFFLL

我相信LL附加到常量保证这个常量将被解释为a long long.

但是,我不希望依赖于long long位数方面的任何特定的编译器相关解释.

因此,我希望我的变量声明不LL使用常量,而是使用:

uint64_t a = static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF);

我想0xFFFFFFFFFFFFFFFF在编译时,编译器不会将常量解释为32位整数uint64_t,这将导致a包含该值的64位整数0xFFFFFFFF,而不是所需的值.

(我目前感兴趣的64位编译器是VS 2010和Ubuntu 12.04 LTS GCC.但是,我希望这段代码能够以任何现代编译器的方式运行.)

上面的代码是否可以满足大多数或所有现代编译器的需要,因此a正确设置的值可以根据需要从常量中包含所有数字0xFFFFFFFFFFFFFFFF,而不包括常量LL的末尾？

(注意:包含I64在常量的末尾会产生编译错误.也许还有另一个令牌需要(或可以)包含在常量的末尾,以告诉编译器将常量解释为64位整数？)

(另外:甚至可能static_cast<uint64_t>是不必要的,因为变量显式被定义为uint64_t？)

我有一个包含5个项目的Xcode解决方案.("解决方案"是整个运行的IDE实例的主要区域及其所有项目的Visual Studio术语;我不确定Xcode等效术语是什么.)

我想对所有5个项目进行清理/重建.

不幸的是,当我选择Product - > Clean时,Xcode 只清理5个项目中的一个.您可以在下面的第二个屏幕截图中看到这一点

Xcode选择清理的项目(在5中)是可执行文件(应用程序).在我希望Xcode清理的其余4个项目中,1个是动态库,3个是静态库.

如何使用Xcode,我能够清理解决方案中的每个项目,而不仅仅是一个项目？

以下是我的设置的屏幕截图.

(1)Xcode主屏幕截图,显示左窗格中列出的5个项目.

(2)日志的屏幕截图,显示我尝试通过Project - > Clean清理解决方案中的所有项目.在左窗格中选择了顶部(最近的)条目.在主窗格中,您可以看到解决方案中的5个项目中只有1个实际上已被Xcode清除.

谢谢!

附录

回应马丁的回答.我在选择项目菜单时按住了Option键,但没有看到"clean build folder"选项.见截图.

(3)项目菜单的屏幕截图显示,当按住Option键选择了Project菜单时.

我有一个稍微复杂的类数据成员,如下所示:

class BranchOutputRow
{
...
}

class Foo
{

public:

    // Slightly complex data member here
    std::map<boost::multiprecision::cpp_int, std::set<BranchOutputRow>> hits;

    void DoLoop1()
    {
        // This loop calls the std::pair<> constructor

        std::for_each(hits.cbegin(), hits.cend(),
        [&](std::pair<boost::multiprecision::cpp_int,
                      std::set<BranchOutputRow>> const & hit)
        {
            ...
        }
    }

    void DoLoop2()
    {
        // This loop does NOT call the std::pair<> constructor

        for (std::map<boost::multiprecision::cpp_int,
                      std::set<BranchOutputRow>>::const_iterator hitsPtr 
                    = hits.cbegin();
         hitsPtr != hits.cend();
         ++hitsPtr)
         {
             ...            
         }
    }

}

int main()
{
    Foo foo;
    foo.hits[1] = std::set<BranchOutputRow>();
    foo.hits[1].insert(BranchOutputRow());

    foo.DoLoop1(); // direct access …

在C++ 11标准中的位置它禁止'template <typename T> class A {...}; template <typename T> class A <int> {...};' (如果有的话)？,已经确认在C++ 11标准中不允许使用以下语法:

/* invalid C++ */

template <typename T>
class A
{
    public:
    T t;
};

// phony "full specialization" that mistakenly attempts
// to introduce a *new* template parameter
template <typename T>
class A<int>
{
    public:
    int i;
    T t;
};

完全理解上面的语法并不代表有效的C++,但我可以想象一下语法上明确使用上面的代码片段,如下所示:

A<float> a1;
A<int><double> a2;

a1.t = 2.0f;
a2.i = 2;
a2.t = 2.0;

对于C++来说,支持上面的语法似乎在语法上和语义上都是明确的.

(如果任何人都不清楚预期的语义,请发表评论,我会解释.)

我会将此语法描述为"在完全专业化中引入新模板参数".

在这个被修改为支持上述语法和语义的C++编译器的想象场景中,编译器将看到A<int> a2;并识别出尝试的实例化与主模板匹配; 然后它将搜索特化并找到并选择完整的专业化 …