Question

如果我界定了控制结构内的一个变量,那么这种控制结构的实行,而不是在整个执行封闭职能时,是否存在?

我如何监测我方案的确切记忆使用及其变化(即:通过制造和销毁变量改变记忆的使用)?

added later: in following code I know v scope is if block, but I want to know whether v is created/destroyed in the memory at the start/end of the if block or at the start/end of the function func?

void func ()
{
    if (true)
    {
        int v;//automatic storage class
        v = 1;
    }
}

Answer 1

如果我界定了控制结构内的一个变量,那么这种控制结构的实行,而不是在整个执行封闭职能时,是否存在?

取决于您的<><> > 声明。页: 1

The variable is only accessible in the scope where you declare it. It can be accessed beyond tht scope if you explicitly pass it around but if it remains valid would depend on the storage type of the variable.
For eg: static variables remain alive throughout the program lifetime, while,
returning address of an automatic variable from an function would result in Undefined Behavior because the variable does not remain valid after the function returns.

Good Read: What is the difference between a definition and a declaration?

我如何监测我方案的确切记忆使用及其变化(即:通过制造和销毁变量改变记忆的使用)?

我认为,你希望获得关于动态分配的物体的信息,因为自动物体的寿命仅够长,将自动销毁,从而不会造成任何问题。

For dynamic objects You can use memory profiling tools like valgrind with Massif or you could replace new and delete operators for your class and collect the diagnostic information.

<>光线> 处理更新的Q。

下面的代码I知道v scope is if >,但我想知道,在功能的起步或起/起步时,在记忆中是否建立了<代码>v<>/code>?

v is created when the scope in which it is declared starts and the statement where it is declared gets executed. v is destroyed once the scope ends i.e } is reached.
This concept is used for forming the basis of one of the most widely used concepts in C++ known as Resource Allocation is Initialization(RAII). Every C++ programmer absolutely must know about it.

简单的做法是通过这一小改动证明和销毁这些物体:

#include<iostream>
class Myclass
{
    public:
        Myclass(){std::cout<<"
In Myclass Constructor ";}
        ~Myclass(){std::cout<<"
In Myclass Destructor";}
};

void func()
{
    std::cout<<"
Before Scope Begins";
    if (true)
    {
        Myclass obj;//automatic storage class
    }
    std::cout<<"
After Scope Ends";
}

int main()
{
    std::cout<<"
Before Calling func()";
    func();
    std::cout<<"
After Calling func()";
    return 0;
}

产出如下:

Before Calling func()
Before Scope Begins
In Myclass Constructor
In Myclass Destructor
After Scope Ends
After Calling func()

Answer 2

A local variable is limited in scope to all the code below the declaration until the end of the enclosing block. The variable is also visible to any other blocks that are enclosed in the original block.

更多信息

Answer 3

如果地方变量is物体,则该物体的寿命在被宣布变数的区块结束时终止。例:

Foo x;            //  lifetime of "x" begins

{
    some_stuff();

    Foo y;        //  lifetime of "y" begins

    Foo & a = x;  //  local variable "a", no new object

    more_stuff();

}                 //  lifetime of "y" ends; "y" and "a" go out of scope

                  //  (lifetime of "x" ends with its surrounding scope,
                  //   or end of program if it was global)

友情链接