I'd guess that what's holding up the program is printing to the console output, which is a slow process. Try writing to a file instead and it'll probably help with speed. Then see if you need to...

You really should comment your code.
And on a side note check out cin.ignore(); after cin>>'ing.

Uh.... what?

cin.ignore() I think.

>> sizeof( any pointer ) is always the same

>> That happens to be true for the garden variety PC of today, but it is not true as a generic statement.

Also, on the same system fat pointers are...

All that changes with iterators that aren't 'int's is the template argument. http://www.cplusplus.com/reference/stl/vector/erase/
std::vector<randomType> myVec;
// Fill the vector with something...

Someone asked something similar before in another forum (http://cboard.cprogramming.com/cplusplus-programming/107469-custom-loose-coupling-string.html) and you could do something like this.class...

You could have it so the constructor requires a flag to ID the allocated item... so something like...class base {
public:
enum derrivableIDs {
idBase,
idOne,
idTwo
};
...

Curious. You should use std::strings really...std::string strItoA(int number) {
std::ostringstream sin;
sin << number;
return sin.str();
}Though Narue may tell you to generalise...

http://www.codeguru.com/forum/showthread.php?t=302806
First hit on google.
Basically, it extracts segments from a varaible, i.e. the higher or lower 16 bits.

You should read about getline here, http://www.cplusplus.com/reference/iostream/istream/getline/

Personally, I'd use std::string-s and getline... #include <string>
#include <fstream>
#include...

Nah. You'll probably have to specialise the template, I'd say. Or overload a > operator, if you feel like it.

You can do what's called 'template specialisation' which will implement certain functions for a specific type, basically.
template<typename ty>
class myClass {
private:
ty var;

public:
...

Nope.
class thing {
private:
std::string str;

public:
thing(std::string _str)
: str(_str) {
}
std::string &getAttribute() {

aa is a pointer so you have to either dynamically allocate an instance of a, or set it to the address of an already instantiated instance, and call aa->getAttribute();. Alternatively doaa a;...

Well, there are two common ways you can represent complex numbers. One is a+ib where i is the root of -1, which is NOT -1. This is called the Cartesian (or rectangular) coordinate system. The second...

goto (http://xkcd.com/292/)

I think you might have to return a reference/pointer to the stream. Though if it's a local variable you might have to return a dynamically allocated stream.

>> Gee, what more do you want?
A clickable link would be nice. I don't want to have to copy and paste again, Salem!

Because they do input or output. One could say the same about your FileHandler class. Meh. If you're only gonna be reading use ifstream, only writing use ofstream, if you're gonna be doing both use...

If you use fstream you can both read and write to the strem. http://www.cplusplus.com/reference/iostream/fstream/ To be honest, I don't see the point in reinventing the wheel, but what the hey. Why...

I made one list (mylist *l) and added an element to it (l->next = new mylist;), then compared items in the same list (iter->num > iter->next->num). iter is simply a pointer which points to the...

Here's a very crude example which I haven't tested, but even if it doesn't work it'll show you how to go about the problem...struct mylist {
int num;
mylist *next;
};

int main( void ) {
...

Maybe something like:nodo *p1, *p2;

p1 = List;
p2 = List->next;

if ( p1->key == p2->key ) // or p1->key == p1->next->key
// do this...Your problem is that you don't have a random access...

In my opinion without some careful management it's asking for trouble. Why do you have to open it? Couldn't you do something like...std::[i/o]fstream fstr;

// ...

fstr.open( "file_name" );...

To understand the reasoning of this execute the following:int main() {
std::cout<< sizeof( unsigned long) << ", " << sizeof( unsigned short ) ;

return 0;
}Basically short*short = short, but...

#include <iostream>
#include <vector>


int main( void ) {
// 4x5 (4 in x, 5 in y) array, containing -1
std::vector< std::vector<int> > vvint( 5, std::vector<int>( 4, -1 ) );

for( int...

So it'll say like 13 and you want to grab the next 13 characters? Will the length actually be wrapped in []? If ya have boost installed use boost::regex for the simplest way. You might be able to use...

Maybe try a:
void printMe const {
// Code here...
}

Wha'?

Why do you need to cast or even make a and b? Just test num1 and num2:using namespace std;
int main()
{
while(1)
{
int num1, num2;
cout << "Insert two numbers" <<...

Change:
if (guess< number, tries++)

to
tries++;
if (guess< number)
// ...
else if (guess>number )
//...You should only need to increment tries once.

<iostream.h>, <stdlib.h> and <time.h> should not be used. Use instead <iostream>, <cstdlib>, and <ctime> In terms of <iostream.h> ... it's old. <iostream> is new and good. The other two are used in...

Probably. That's the way I do it. You can also, if you wish, look into LoadLibrary (capitalisation?).

#include <my_dll.h>
#pragma comment( lib, "my_dll.lib" )

int main() {
my_dll_function();
return 0;
}Should work with your IDE.

Well, as nice as command != ('A' || 'B') looks it doesn't work like that. if( command != 'A' || command != 'B' ) is what you're looking for, but to be honest a straight out else should do -- it's...

>> Could anybody help me with the code please?
Not unless you show some work.
But it's not that hard. There are two problems to overcome -- 1) filling the array 2) reading values from a file. Once...

I really don't know what you mean. Do you want to save integers to file? Binder?

I'm pretty sure you're making that up, or at least mistaking it.
Do you have a cin.ignore() or cin.get() or something before the function is called?

Also, you should use std::string to read in...

One thing you could do is map out a directory. The structure could have the name of the directory, an array of sub-directories (which would possibly be a pointer to a new instance of the structure...