小编ana*_*lyg的帖子

假设我有一个不可复制的类Foo,其中一个构造函数恰好接收了对它的引用Foo.

class Foo
{
public:
    Foo(Foo& parent) {...}

private:
    void operator=(Foo); // disabled
    ...
};

编译器认为这是一个复制构造函数,而它完成与复制完全无关的事情(因此禁用赋值运算符).

以这种方式定义构造函数是否存在任何危险,或者我应该人为地更改其签名,例如使用指针而不是引用,还是添加必需的伪参数？

这是一些背景(可能不需要理解/回答我的问题).

我有一个我自己编写的类库,它用作用户代码和另一个库之间的连接.另一个库提供了一个服务,我称之为frobnicate为简洁.用户代码可能如下所示:

class UsefulObject: public mylib::Frobnicator
{
    ...
    void DoStuff()
    {
        int x = ...
        ...
        frobnicate(x); // it's important to allow simple syntax here
        frobnicate(x + 1);
        ...
    }
    ...
};

我想支持用户对象的层次结构:每个对象都包含在另一个(其父对象)中,而有一些(在我的情况下,5个)顶级对象包含其他所有对象.

每个对象都有一个日志文件; 我希望每个调用都记录在几个日志文件中,在包含层次结构中,直到顶级对象.

我用这种方式实现了它:

namespace mylib
{
    class Frobnicator // provides the frobnication service
    {
    public:
        Frobnicator(Frobnicator& parent): parent(parent) {}
    protected:
        virtual void …

我正在尝试编写一个通用函数来排序不同类型的数据.我的代码是:

#include<stdio.h>
#define GENERIC_SORT(TYPE) \
TYPE ##_SORT(TYPE a[],int n) \
{  \
int i,j; \
TYPE aux; \
for(i=1;i<n;i++) \
    for(j=n-1;j>=i;j--) \
    if(a[j]<a[j-1]) \
{ \
    aux=a[j]; \
    a[j]=a[j-1]; \
    a[j-1]=aux; \
} \
}
GENERIC_SORT(int)
GENERIC_SORT(float)
GENERIC_SORT(double)
GENERIC_SORT(char)
int main(void)
{
int i,a[]={3,7,5,4,6,1};
int_SORT(a,6);
for(i=0;i<6;i++)
    printf("%d ",a[i]);
return 0;
}

我正在准备考试,在课程中有一个例子GENERIC_MAX,它找到2个值之间的最大值.而且我应该像这样做...

它的工作原理罚款int,float,double和char.但是如何使用它来对字符串数组(char a[][100]或char *a[])进行排序？

为什么我们不能将指针的地址存储在另一个指针中？指针只是一个特殊类型的变量,它有一些地址,但为什么我不能将该地址存储到另一个指针？

int main()
{
    int * ptr;
    int * q;
    q = &ptr;
}

为什么这段代码错了？

我有3个文件

hellomain.c
hellofunc.c
helloheader.h

我正在通过 GCC 编译器运行。通常我会输入：

gcc helloheader.h hellomain.c hellofunc.c -o results

一切都会运行。

如何将其转换为 makefile？我知道我必须给它加上标题makefile。我知道我必须通过make在编译器中输入来调用它。但不确定在 makefile 中实际输入什么。

我正在处理一些大型文本文件,即.将它们从一种格式转换为另一种格式.文件的原始格式存在一些细微差别,但是 - 在少数情况下进行了一些预处理 - 它们大部分都是使用我创建的bash shellcript成功转换的.

到目前为止一切都那么好,但有一件事令我困惑.$iterations有时,脚本会设置一个名为的变量,以便它知道执行特定for循环的次数.此值由脚本创建的临时文件中的空行数确定.

因此,我的脚本的原始版本包含以下行:

    iterations=$(cat tempfile | grep '^$' | wc -l)

到目前为止,除了其中一个文本文件之外,其他所有文件都没有$iterations正确设置变量,即使看起来有超过20,000个空行,也给出了值"1" tempfile.

然而,在发现之后grep -c,我将线路改为:

    iterations=$(cat tempfile | grep -c '^$')

并且剧本突然起作用,即.$iterations设置正确.

谁能解释为什么这两个版本会产生不同的结果？为什么第一个版本适用于某些文件而不适用于其他文件？是否有一些上限值,wc -l默认为1？这不会与第一个版本的工作文件是最大的一个,但不是在中集(其正确地转换第一次)最大.

在我寻找一个可以处理多种语言并以增量方式构建代码的构建系统时，我发现 Bazel 是一个非常好的解决方案。然而，有一个问题我没有解决方案。

我有带有循环依赖关系的 C++ 代码。在问题解决之前，我需要一个可以构建此类代码的构建系统。我的问题是，Bazel 可以构建具有循环依赖的代码，尤其是 C++ 代码吗？如果是，有人可以分享指南或一些有用的链接吗？

我是c ++的初学者,我遇到了使这段代码按照我想要的方式工作的问题.任务是编写一个程序,将所有自然数乘以加载数n.

为了使打印出正确的结果,我分x的n(见下面的代码).如何进行打印x而不必将其除以n得到正确的答案？

#include<iostream>
using namespace std;
int main(){
    int n,x=1;
    int i=0;
    cout<<"Enter a number bigger than 0:"<<endl;
    cin>>n;
    while(i<n){
        i++;
        x=i*x;  
    };
    cout<<"The result is: "<<x/n<<endl;
    return 0;
}

假设我正在编辑一些大型C++源文件,并添加了几行恰好使用的代码,auto_ptr如下例所示.

#include <string>

// ... (much code here)

void do_stuff()
{
    std::string str("hello world");
    // ... (much code here too)
    std::auto_ptr<int> dummy; // MY NEW CODE
    // ...
}

这个例子在gcc 3.4.4(cygwin)上编译,因为标准头部<string>恰好包括<memory>编译所需的头部auto_ptr.但是,这不适用于gcc 4.5.0(mingw); 他们似乎已经清理了他们的头文件或其他东西.

所以,当我添加使用的代码时,我auto_ptr应该立即查看该文件是否包含#include <memory>在开头,这个答案意味着什么？我从来没有这样做(我觉得太烦人了); 我总是依赖编译器来检查是否有任何#include缺失.

是否有任何选项不会破坏编码,并确保我的代码的可移植性？

是否有一个C++标准库实现,其标题不是必需的彼此包含？

我经常使用前瞻性声明; 它们有助于避免许多问题#include,缩短编译时间.但是如果我想在标准库中转发声明一个类呢？

// Prototype of my function - i don't want to include <vector> to declare it!
int DoStuff(const std::vector<int>& thingies);

我听说有人禁止/无法向前宣布std::vector.现在这个无关问题的答案建议用这种方式重写我的代码:

stuff.h

class VectorOfNumbers; // this class acts like std::vector<int>
int DoStuff(const VectorOfNumbers& thingies);

stuff.cpp

// Implementation, in some other file
#include <vector>
class VectorOfNumbers: public std::vector<int>
{
    // Define the constructors - annoying in C++03, easy in C++11
};

int DoStuff(const VectorOfNumbers& thingies)
{
    ...
}

现在,如果我在整个项目中使用VectorOfNumbers而不是std::vector<int>在所有上下文中,一切都会很好,我不再需要#include …

第一个和第二个案例有什么区别,为什么第一个工作按预期工作,而第二个工作没有？(在第二种情况下,我试图引入一个指针,取消引用指针指针,以避免键入额外的星号).

int _tmain(int argc, _TCHAR* argv[])
{
    int* test = NULL;
    foo(&test);
}

情况1:

void foo(int** ppPar)
{
    *ppPar = (int*)malloc(sizeof(int));
    **ppPar = 7;
}

案例2:

void foo(int** ppPar)
{
    int* pPar = *ppPar;
    pPar = (int*)malloc(sizeof(int));
    *pPar = 6;
}