小编Nul*_*ull的帖子

我正在使用Doxygen来记录我的代码.许多代码在cpp文件中都有匿名命名空间,其中定义了常量.我已经设定:

EXTRACT_ANON_NSPACES = YES

在我的Doxygen文件中,所有匿名命名空间都记录在案.

我的问题是我想在匿名命名空间中引用一个变量.例如,假设其中一个名称空间在我的Doxygen文档中定义MyClass::anonymous_namespace{MyFile.cpp}::kMyConstant.我认为另一个注释块(例如,对于一个函数)可以链接到该常量,如:

@see MyClass::anonymous_namespace{MyFile.cpp}::kMyConstant

不幸的是,我得到的唯一链接是MyFile.cpp,但不是通过匿名命名空间到常量变量.显然我想这样做,以便如果常量的值发生变化,文档将在重新运行Doxygen时引用新值.如果常量发生变化,将常量的显式值放在文档中将是危险的.

我的格式不正确吗？我已经广泛搜索了这个答案,但无济于事.

boost::optional<T>(1.51)提供了一种构建对我的用户非常危险的对象的方法,我想阻止它.假设我有自己的整数类,我想传递一个可选的这样的整数并将其存储在某个类中:

class myint {
public:
    int m_a;
    myint (int r_a) : m_a(r_a) {
    }
};

struct myclass {
    boost::optional<myint> content;
    myclass (const boost::optional<myint>& arg) : content(arg) {
    }
};

现在,这是用户如何使用该类:

myclass(myint(13));            //correct use
myclass(boost::none);          //correct use
myclass(myint(0));             //correct use
myclass(0);                    //INCORRECT use, this easy typo
                               //equates boost::none which
                               //is not what the user meant

我想了解这里发生了什么,并防止这种行为.

有趣的是,

myclass(1);              //does not compile

boost::none对于我的领域来说,这完全是一个有效的价值,但是boost::none当用户试图输入时,有一个偷偷摸摸的东西0是极其误导和危险的.

意图可能有点隐藏,因为我并没有真正推出一个myint课程而且我真的class myclass没有任何目的.无论如何,我需要向函数发送10个左右的可选ints,并且重复数据删除不起作用.(你可以想象我问你的年龄,身高和财富,还有三个特殊按钮可以检查你是否不想回答问题)

我发布了一个似乎在下面工作的答案(根据Mooing的Duck&Ilonesmiz建议,但更轻).不过,我很高兴听到有关它的评论.

我正在尝试编写一个函数,它接受两个数字并打印出它们的总和.

#include <iostream>

using namespace std;

int plus(int, int);

int main () {
 int a, b, result;
 cout << "2 numbrs";
 cin>>a>>b;
 result = plus(a,b);
 cout << result;
 return 0;
}

int plus(int a,int b) {
 int sum;
 sum = a+b;
 return sum;
}

我得到的错误:

use of `plus' is ambiguous

这是我的第一个C++程序,事实上我正在盲目地发现错误.

我已经教自己编程了几年,我确信如果你需要变量编号的数组声明,你需要使用malloc或new.

今天我发现这在g ++版本4.4.4下编译,没有警告或错误:

#include <iostream>
using namespace std;

int main()
{
    int size_array;
    cin >> size_array;
    int iTable[size_array];

    for(int i=0;i < size_array;i++)
        iTable[i]=i*i;
    for(int i=0;i < size_array;i++)
        cout << iTable[i] << endl;

    return 0;
}

如果你使用gcc(更改后cout和cin使用printf和scanf),它也可以完全编译

在Visual Studio下,此代码无法编译,因为size_array它不是常量.

什么时候改变了？这是一种安全的方法吗？

我正在开发一个应用程序,如果输入的数据有三种可能的大小:

• 小:1000个元素
• 中= 5000个元素
• 大= 500,000个元素

问题是我无法分配大型数组.似乎不接受大于5000的尺寸.

我执行以下操作时出现运行时错误:

long  size=1000;
char ch;
int arr[size];
ch=getch();

if(ch==..)
  size=...;

1000和5000的尺寸似乎工作正常,但我怎么能以这种方式制作500k的阵列？

我有两个(x,y)点开始和结束.我想从头到尾制作动画,但不是采用线性方式,而是想创建一个弯曲的路径.

我很确定我不是在寻找缓和因为我不想影响动画速度,我只想计算弯曲路径.

我发现我需要某种控制点,如下图所示:

但我不知道如何实现它.我很想创建一个采用以下参数的函数

function calculateXY(start, end, controlpoint, percentage);

其中百分比是0到100%之间的数字,其中0表示返回起始位置,100%表示结束位置.

解决方案不需要在Objective-C中,它可以是任何编程语言.我只是无法理解数学:)

根据JLS:如果命名类的实例变量初始化程序或实例初始值设定项可以抛出一个已检查的异常类,那么这是一个编译时错误,除非在每个构造函数的throws子句中显式声明了该异常类或其一个超类.它的类和类至少有一个显式声明的构造函数.

所以,如果我这样做 -

class A{
 {
  throw new FileNotFoundException();
 }
public A() throws IOException{
    // TODO Auto-generated constructor stub
}
}

这给出了编译时错误"初始化程序必须正常完成"

而

class A{
 {
  File f=new File("a");
  FileOutputStream fo=new FileOutputStream(f);
  fo.write(3);
 }
public A() throws IOException{
    // TODO Auto-generated constructor stub
}
}

此代码不显示任何编译时错误.即使我在构造函数中声明了throws子句,为什么前面的代码不能编译？

鉴于此代码......

public class SimpleTest {

  @Test
  public void testCompletableFuture() throws Exception {
    Thread thread = new Thread(SimpleTest::longOperation);
    thread.start();

    bearSleep(1);

    thread.interrupt();

    bearSleep(5);
  }

  public static void longOperation(){
    System.out.println("started");
    try {

      boolean b = true;
      while (true) {
        b = !b;
      }

    }catch (Exception e){
      System.out.println("exception happened hurray!");
    }
    System.out.println("completed");
  }

  private static void bearSleep(long seconds){
    try {
      TimeUnit.SECONDS.sleep(seconds);
    } catch (InterruptedException e) {}
  }
}

想象一下,不是这样,while(true)你有一些不会抛出中断执行的东西(例如,一个实际计算某事的递归函数).

你怎么杀这个东西？为什么它不会死？

请注意,如果我不把Exception类型放在那里使用InterruptedException它甚至不会编译,说"interrupted exception will never be thrown"我不明白为什么.也许我想手动打断它...

在尝试编写有关移动构造函数的示例后,我遇到了以下代码:

#include <utility>
#include <iostream>

using namespace std;

class Data
{
public:
    Data()
    : x (3)
    {
        cout << "Data()" << endl;
    }
    Data(Data&&)
    : x(4)
    {
        cout << "Data(&&)" << endl;
    }

int x;
};

int main()
{
    Data a;
    Data b (std::move(a));
    cout << b.x << endl;
    return 0;
}

为什么移动构造函数不在这里调用？程序打印:

数据()

3

我发现甚至更奇怪的是,通过添加一个复制构造函数,突然,它确实调用了移动构造函数...

    Data(const Data&)
    : x(2)
    {
        cout << "Data(copy)" << endl;
    }

现在它将打印出来

数据(&&)

4

PS我正在使用gcc 4.4.5

在 Visual Studio 中，警告 C4996（使用不推荐使用的函数）被视为错误，使用不推荐使用的函数的代码根本不会编译。

有多种方法可以完全禁用 C4996，可以为单行、翻译单元或整个项目禁用它。但是如果我希望它仍然发出警告，但允许编译而不将其视为错误怎么办？

#include <iostream>

[[deprecated]]
void deprecated_function()
{
    std::cout << "I function, but have been deprecated.\n";
}

int main() {
    deprecated_function();
}

这根本无法编译。

#include <iostream>

[[deprecated]]
void deprecated_function()
{
    std::cout << "I function, but have been deprecated.\n";
}

int main() {
#pragma warning(suppress: 4996)
    deprecated_function();
}

这会编译，但根本不会发出警告。

对于已弃用的函数，是否可以告诉 Visual Studio 发出警告，但仍允许编译？我正在考虑重构目的，我想将一个函数标记为已弃用，标识它使用的所有位置，但代码仍在每个中间阶段编译，其中一些但不是所有已弃用函数的用途已被替换。

我正在使用 Visual Studio 2019 Community 16.8.4 进行编译，警告级别设置为 /W3，“将警告视为错误”设置为“否”。如果发出此特定警告，它似乎被视为错误。