labeled breaks

[soljaragz]

Here is some code in java I want to put in C++

	out:
			for(int u=0;u<N;u++)
			{
				
				Arrays.fill(dist,20000);
				int source = u;
				dist[source] = 0;
				
				for(int i=0;i<N;i++)
				{
					for(int k=0;k<edges;k++)
					{
						int sol = dist[ t[k] ] + c[k];
						int v = f[k];
						if( dist[v] > sol  )
							dist[v] = sol;
						 
					}
				}
				for(int k=0;k<edges;k++)
				{
					if( dist[ f[k] ] > dist[ t[k] ] + c[k])
					{
						negcycle = true;
						break out;
					}
				}
			}

Since c++ dont have labeled breaks, how would I code the above?

[soljaragz]

would this be fine?

		for(int u=0;u<N;u++)
			{
				memset(dist,20000,sizeof(dist));
				int source = u;
				dist[source] = 0;
				
				for(int i=0;i<N;i++)
				{
					for(int k=0;k<edges;k++)
					{
						int sol = dist[ t[k] ] + c[k];
						int v = f[k];
						if( dist[v] > sol  )
							dist[v] = sol;
						 
					}
				}
				for(int k=0;k<edges;k++)
				{
					if( dist[ f[k] ] > dist[ t[k] ] + c[k])
					{
						negcycle = true;
					    goto outside;
					}
				}
			}
			outside:

[CornedBee]

It would. However, a more respected way is to activate the termination condition for the outer loop and then break then inner. In your case, set u to N before breaking.

[rynoon]

would this be fine?

 goto outside;

It's best to avoid goto statements whenever possible. I'd try something like...

for(int u=0;u<N;u++)
			{
				
				//snip

                                bool bOut = false;
				for(int k=0;k<edges;k++)
				{
					if( dist[ f[k] ] > dist[ t[k] ] + c[k])
					{
						negcycle = true;
                                                bOut = true;
						break;
					}
				}

                                if(bOut)
                                        break;
			}

[Salem]

> memset(dist,20000,sizeof(dist));
This isn't a replacement for arrays.fill

Rynoon's answer seems OK, but isn't negcycle also the same flag?

[Daved]

Breaking nested for loops is one of the few uses of goto that is considered acceptable, although whether it is a good choice is debatable. I personally would first try to factor out another function if it makes sense. If not, then I'd probably use something similar to rynoon's example.

Incidentally, I believe something similar to a labeled break is being considered for the next C++ standard, although I don't recall how likely it is to get in.

[DV64h]

rycoons answer is the only clean solution to this. labeled breaks are just not something for c++. break just indicates to quit the loop, where java does much of the memory management for you, in c++ your responsible for it yourself so labeled break statements could lead to serius problems. I dont think they ever gonna put it in the next standard

[CornedBee]

I've no idea what you mean, DV. Even goto respects destruction of objects when leaving scopes (and I pity the compiler writers for having to implement this).