小编Luc*_*uca的帖子

我对使用try/catch/finally子句有疑问,让我解释一下:我知道在声明中声明异常规范的每个方法都必须用try块包围(在调用方法中),然后是一个可以捕获该异常的catch块(除非我没有声明调用方法也抛出异常).如果调用方法在try-catch之后有其他语句,那么无论发生什么(抛出或不抛出异常)都会执行这些语句.所以,如果我有以下代码:

 public class ExceptionCall {
   Throwing t = new Throwing();
    public void methodTry(){
        while(true){
            try {
                if (t.flag++==0)
                    t.throwing();
                System.out.println("no exception");
            } 
            catch (MyException e) {
                e.printStackTrace(System.err);
                System.out.println("working on it!");
            }
            finally{
                System.out.println("finally clause");
            }
                System.out.println("out");
                if (t.flag==2) 
                    break;  
        }
    }
}

这里Throwing有一个名为(guess what :))throw()的方法,它被声明为抛出一个MyException exception,并且有一个名为flag的公共字段,其中包含一个初始化为0的int,以提供一种条件检查.

因此,无论try块中发生什么,都会执行几次保护区域外的代码.

所以我的问题是,最后一块是什么？我的意思是,我知道当调用方法从try或catch块返回时它会派上用场(在这种情况下我可以在catch中有一个break语句并且finally会被执行),但在这种情况下,这是什么区别？？

我正在学习C++而且我对数组有疑问(我还在研究这个主题,有些事情很清楚,而有些事情对我来说似乎有些模糊).我想知道这些声明是否合法,如果是,它们如何影响新创建的数组:

让我们假设我想创建一个int数组(以保持简单):

我知道以下是合法的

int array[size];

其中size是常量表达式

还有这个

const int array[size];

这个声明意味着我可以读取 - 访问数组中的元素,但我不能分配给它们(int a=array[2]是合法的,array[1]=10是一个错误).

怎么样的"顶级"const喜欢

int const array[size];

要么

const int const array[size];

他们首先是合法的吗？如果是这样,他们是什么意思？不是一个数组常量本身,是不可能分配给一个数组或复制初始化一个？

谢谢!

编辑:

我知道什么是"顶级"和"低级"const意味着(虽然我知道我可以在基本类型说明符之前和之后放置const限定符,但不会改变任何东西).我想知道的是如何定义一个const数组(我的意思是不是一个const对象或变量数组)改变了一些东西.

我正在学习使用Java查找名称,并且来自C++我发现有趣的是,即使Java让我嵌套了很多代码块,我也只能在第一个嵌套作用域中隐藏名称:

// name hiding-shadowing: local variables hide names in class scope

class C {

  int a=11;

  {
    double a=0.2; 

  //{
  //  int a;             // error: a is already declared in instance initializer
  //}

  }

  void hide(short a) {  // local variable a,hides instance variable
    byte s;
    for (int s=0;;);    // error: s in block scope redeclares a
    {
      long a=100L;      // error: a is already declared in (method) local scope
      String s;         //error: s is alredy defined in (method) local …

我是一个相当有经验的 C/C++（在某种程度上，Java）程序员。我正在学习 python，但我对这种语言的一些奇怪的（对于我的背景）行为感到困惑。

我正在学习嵌套函数和闭包（阅读“学习 Python”，这对我来说似乎是一个非常好的来源）。

我明白，如果我在调用创建的函数时将 def 嵌套在 for 循环中，它会查找捕获的循环变量的最后一个值（因为它是通过引用捕获的，就像 C++ 程序员所说的那样）

funcs = []
for i in range(4):
    def f():
        print(i)
    funcs.append(f)

并运行程序的结果是

>>> for f in funcs:
      f()


3
3
3
3

现在，当我偶然发现这个（在我看来）不一致时，我正在考虑这个问题：如果我这样做

for i in range(4):
  funcs[i]()


0
1
2
3

更莫名其妙，如果我这样做

>>> i = 2
>>> funcs[i]()

2

现在，列表中的所有函数都返回 2：

for f in funcs:
  f()


2
2
2
2

一定有一些我无法理解的与范围相关的问题

我试图了解 std::bind 和 std::function 是如何工作的。我无法编译以下代码：

#include <iostream>
#include <string>
#include <functional>

void function(int a, float b, std::string const &s)
{
    std::cout << "printing function" << std::endl;
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << s << std::endl;
}

int main(int argc, char *argv[])
{
    std::bind(&function, 10, 11.1, "hello")();
    std::function<void(int, float, std::string const&)> fun = std::bind(&function, 10, std::placeholders::_1, std::placeholders::_2);

    fun(0.2, "world");

    return 0;
}

编译器抱怨说：

main.cpp: In function 'int main(int, char**)':
main.cpp:16:69: error: conversion from 'std::_Bind_helper<false, void …

我正在研究C ++中的多线程，并且编写了一个简单的类，其中包含一个私有std::mutex对象，以便在调用成员funcrion时进行同步：

#include <mutex>
#include <iostream>

class SynchClass
{
public:
    SynchClass() {}
    void inline SynchronizedInterfaceFunction();    
private:
    std::mutex mMutex;
};

void inline SynchClass::SynchronizedInterfaceFunction()
{
    std::lock_guard<std::mutex> lock(mMutex);

    for (int i = 0; i < 10; i++) 
        std::cout << "thread n: " << std::this_thread::get_id() << " inside function" << std::endl; 

    std::cout << std::endl;
}

现在，此函数具有deleted复制构造函数和复制赋值运算符，因为std :: mutex可以移动，但不能复制/分配。

因此，我为类提供了一个move构造函数（编译器不会自动生成）：

class SynchClass
    {
    public:
        // ... other members as before
        SynchClass(SynchClass &&rhs) : mMutex(std::move(rhs.mMutex)) {}

    };

但是，当我在这行上做广告时，编译器抱怨我试图调用已删除的副本构造函数std::mutex：

In file …

我正在将 FreeRTOS 用于我的一个项目，我正在阅读文档，但有一些我无法理解的内容。我知道上下文切换发生在滴答中断被触发时，因此调度程序执行其工作并取消阻塞等待事件的任务并选择处于就绪状态的更高优先级任务。但是当任务在滴答中断之前阻塞时会发生什么？该文档似乎暗示上下文切换会立即发生（例如，两个具有不同优先级的任务，每个任务都调用 vTaskDelay() 以释放 CPU 时间片）。它是如何发生的？我进行了搜索，但找不到我的问题的任何答案。

EDIT在我FreeRTOS的（SAMD21的Cortex-M0 +）的端口的portYIELD（）宏用于简单地请求SVCall异常，所以这是一个用于（从蜱中断运行调度预留）执行上下文切换的机制？

我正在学习C++,我正在阅读有关STL容器,迭代器以及可以对它们执行的操作的内容.我知道每个容器类型(或者更好,每个类型都是实例的相应模板)定义了一个类似于指针类型的companio类型,它被称为迭代器.我理解的是,一旦你得到一个容器的迭代器,执行像添加元素之类的操作可能会使该迭代器失效,所以我尝试用一​​个例子来测试这个语句:

#include <vector>
#include <iostream>

using namespace std;

int main()
{
  vector<int> ivec={1,2,3,4,5,6,7,8,9,0}; 
  auto beg=ivec.begin();
  auto mid=ivec.begin()+ivec.size()/2;
  while (beg != mid) {
    if (*beg==2) 
      ivec.insert(beg,0);
    ++beg;
  }  
  for (auto i:ivec)
    cout<<i<<" ";
}

在这里,我只是构建一个int向量,大括号初始化它,并执行基于条件的操作,在容器的前半部分插入一个元素.该代码是有缺陷的,我认为,因为我初始化2个迭代器对象beg 和end,然后我在while语句作为条件使用它们.但是,如果代码应该更改容器的内容(并且确实如此)迭代器会发生什么？代码似乎运行得很好,它在ivec [1]位置添加0并打印结果.

我认为beg迭代器会指向新添加的元素,mid迭代器会指向前面指向mid的元素(就像迭代器指向相同的内存位置而底层数组"滑动")在..除非它被重新分配,是)

有人能解释我这种行为吗？