Better way to repeatedly use istringstream in “counting minutes” challenge

In to24HourTime(), pos doesn't need to be passed by reference as it's not being modified. Just pass it by value.

Instead of passing hourToConvert by reference (which is being modified), you can just pass by value and then return the result. It may also increase readability as it'll be clear that the third argument is to be reassigned by the function.

Final changes:

hour1int = to24HourTime(str, stringPos, hour1int);

// ...

int to24HourTime(string timeString, int pos, int hourToConvert) {
    if (timeString[pos] == 'p' && hourToConvert != 12)
        hourToConvert += 12;
    if (timeString[pos] == 'a' && hourToConvert == 12)
        hourToConvert = 0;

    return hourToConvert;
}

using namespace std;

I don't do much C++, but one thing I've learned from the many reviews I've upvoted on this site, I'm 100% positive, it isn't a good idea to import std in the global namespace; instead, refer to std::cout, std::string and std::istringstream.

See this Stack Overflow answer for more details about why it's best to avoid potential name clashes by not importing that namespace.

Also return 0 at the end of the main() procedure is redundant, the compiler should take care of it.

First, you should be aware that although you probably don't care about them in this specific case, there are lots of bits of ugliness to deal with if you try to deal with this issue in general. Time-keeping has so many strange little corner cases it's an absolute nightmare to get it really correct in general. Just for example, if a time crosses a daylight savings time (aka "summer time") boundary, the amount of time could be one hour longer or shorter than this will compute. For the moment, I'm going to assume you don't want to deal with any issues like that though.

Second, the standard library has functions that attempt to make tasks like this quite a bit easier. If you don't want to implement everything on your own, a combination of mktime and difftime will reduce the amount of code you need to write by a fairly substantial factor.

Third, for this particular case, I'd at least consider using scanf instead of using iostreams at all. Given the formatting of the input data, you can consolidate nearly all the data reading down to something on this order:

scanf("%d%:%dc%*c-%d:%d%c%*c", &hour1, &minute1, &ampm1, &hour2, &minute2, &ampm2);

Although scanf can be somewhat tricky to use well (especially to read strings safely), in this case the use is pretty safe--certainly a lot safer than the gets you used to read the input (in fact, you'd be better off if you never used gets again--for anything, under any circumstances).

From there, I'd write a small function that takes an hour and AM/PM indicator, and converts that to hours since midnight:

int to24hour(int hour, char ampm) { 
    if (hour == 12)
        hour -= 12;
    return ampm == 'a' ? hour : hour+12;
}

This gives clearly-defined boundaries between different parts of the code. In main, you read the input from the stream, and get a time as hour (in 12-hour format), minute, and AM/PM indicator.

The next step takes 12-hour format input and produces 24-hour format as output. As your code is written, nearly all the code has to work with the input string as a string, and cooperate in keeping track of a current position in the string. This (for one example) makes it much more difficult for any of the code from being put to other uses--nearly all the code deals directly with the input string, so using it with input in a different format is likely to be difficult.

Summary:

1. Try to isolate code that deals with details like specific input formats into one place.
2. Don't use gets. Ever. For any reason.
3. Outside very strict boundaries, computations involving time get ugly in a hurry. Avoid them if humanly possible.
4. In a few cases (possibly including this one) it's worth considering alternatives to using iostreams directly. They're great for some purposes, but can get ugly for others.