debugging - step into issue

hi...i'm using msvs 2008. in the past, using msvs6, i've stepped through with F10 and F11. i'm new to msvs 2008 and i came across and issue. i can step line by line but it goes way too deep when i step into a function.

can anyone please test this for me?

Code:

void create_list(string filelist)     // when you step into this, it brings up some very low-level code
void create_list(string &filelist)    // steps as it should

Code:

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

void create_list(string filelist);

void main ()
{
string filelist = "filelist";

	create_list(filelist);
}

void create_list(string filelist)
{
string command = "dir /d c:\\ > ";
	command = command + filelist;
	system(command.c_str());
}

thanks...bg742

Obviously that's because it calls the string copy constructor.
Just step out of it (Shift+F11).

it wasn't like that in vs6. any keystroke i can hit so i don't have to go in deep and pull out with shift + F11?

thanks for your fast reply.

bg742

Yes, sometimes you have to "work at it" to step into the function you actually want to step into. If you know where you are going to end up (that is, it's not a function pointer/method call) it is often easier to jump to the beginning of that function and set a breakpoint.

--
Mats

You can jump over such things with F10. Just don't do it when calling your functions as it will step over them, as well.

Originally Posted by barneygumble742

it wasn't like that in vs6. any keystroke i can hit so i don't have to go in deep and pull out with shift + F11?

thanks for your fast reply.

bg742

I do not have such behavior with your code. So it maybe a result of the STL library installed or some settings in your environmet


As aSide note - you probably should read the FAQ about void main

Originally Posted by barneygumble742

it wasn't like that in vs6.

There are a few reasons why that was.

1. VS6 had a broken debugger.
2. VS6's STL library sucked like a vacuum.

Basically, what you're seeing now it what you always should have seen. Imagine trying to step into a call like this:

Code:

int x = foo(a.getValue(), b.getValue());

You might be trying to step in to the foo() function, but if you hit F11 you go into getValue() twice before you get there. Either set a manual breakpoint at foo(), or just hit Shift-F11 to get out of the function you are not interested in, then hit F11 again.

Originally Posted by brewbuck

You might be trying to step in to the foo() function, but if you hit F11 you go into getValue() twice before you get there. Either set a manual breakpoint at foo(), or just hit Shift-F11 to get out of the function you are not interested in, then hit F11 again.

And if foo takes a different type to what getValue returns, then you'll step into two constructor calls as well.
It's not uncommon to step into and out of say 8 things before getting to the one you meant. Just put a breakpoint in the function you're stepping into for cases like that.

It is another good reason to pass objects by reference (const when appropriate) rather than by value, as you've no doubt already noticed.