Thread: quick goto question

I just have a quick goto question.

if you have some code like

Code:

start:

int a;
cin >> a;
cout << a;

goto start;

how does that handle the variable declaration?

Does it skip over it after the first time becuase a is already declared?
Or does it create it over and over agian?

I know that goto statments are a bad idea, i was just curious about this.

thanks

This doesn't compile:

Code:

int main(){
	goto aaa;
	int* something=new int();

aaa:
	*something=0;
	return 0;
}

And the compiler errors (MS VC++6):

Code:

 error C2362: initialization of 'something' is skipped by 'goto aaa'
        see declaration of 'something'

CPP Standard Section 6.7 Paragraph 3
It is possible to transfer into a block, but not in a way that bypasses declarations with initialization. A program
that jumps77) from a point where a local variable with automatic storage duration is not in scope to a
point where it is in scope is ill-formed unless the variable has POD type (3.9) and is declared without an
initializer (8.5).

Code:

[Example:
void f()
{
// ...
goto lx; // ill-formed: jump into scope of a
// ...
ly:
X a = 1;
// ...
lx:
goto ly; // OK, jump implies destructor
// call for a followed by construction
// again immediately following label ly
}
—end example]

Closest thing I could find ATM to what the OP wanted:

CPP Standard Section 15 Paragraph 2
A goto, break, return, or continue statement can be used to transfer control out of
a try block or handler. When this happens, each variable declared in the try block will be destroyed in the
context that directly contains its declaration.

Code:

lab: try {
T1 t1;
try {
T2 t2;
if (condition)
goto lab;
} catch(...) { /* handler 2 */ }
} catch(...) { /* handler 1 */ }

Of course thats in different blocks so it might be different if its in the same block

Formally, the goto statement is never necessary, and in practice it is almost always easy to write code without it.

Never say never
The discussion has been discussed and within some very tight requirements there has been a need for a goto.

I don't know Hunter that sounds a lot like this problem

goto statements only have good uses when control flow passes down from the function. In terms of style and understanding, code such as

Code:

void f(int i) 
{
      if (i == 0)
           goto exit;

      std::cout << "Hello" << std::endl;

exit:
}

is the same as

Code:

void f(int i) 
{
      if (i == 0)
           return;

      std::cout << "Hello" << std::endl;
}

The issue concerning object constructor initialization also occurs with switch statements. For example, you cannot write

Code:

switch(1) {
case 1: 
        int foo;
        break;
case 2:
        break;
}

(Each case does not define a new lexical scope block. )