Pero esque la idea esque no repitas caminos xD.

De todas formas si solo buscas una salida, no necesitas que sea aleatorio. Te abasta con hacerte alguna estructura que permita recursión (lista o pilas), le pones un while ya debería ir.

Función que determina si dos puntos A y B están conectados:

#include <stack>
 
bool explora(char mat[][20],Cord inicio,Cord Destino,int TAMX,int TAMY)
{
    stack<Cord> Pila;
    Pila.push(inicio);
 
    while (Pila.size() != 0)
    {
        //cout<<Pila.top().x<<" , "<<Pila.top().y<<endl;
        // izquierda
 
        if (Pila.top().x > 0)
        {
            if (Pila.top().x-1 == Destino.x && Pila.top().y == Destino.y) return true;
            if (mat[Pila.top().x-1][Pila.top().y] == 0)
            {
                mat[Pila.top().x-1][Pila.top().y] = 1;
                Pila.push(Cord(Pila.top().x-1,Pila.top().y));
                continue;
            }
        }
 
        // derecha
 
        if (Pila.top().x < TAMX-1)
        {
            if (Pila.top().x+1 == Destino.x && Pila.top().y == Destino.y) return true;
            if (mat[Pila.top().x+1][Pila.top().y] == 0)
            {
                mat[Pila.top().x+1][Pila.top().y] = 1;
                Pila.push(Cord(Pila.top().x+1,Pila.top().y));
                continue;
            }
        }
 
        // arriba
 
        if (Pila.top().y > 0)
        {
            if (Pila.top().y-1 == Destino.y && Pila.top().x == Destino.x) return true;
            if (mat[Pila.top().x][Pila.top().y-1] == 0)
            {
                mat[Pila.top().x][Pila.top().y-1] = 1;
                Pila.push(Cord(Pila.top().x,Pila.top().y-1));
                continue;
            }
        }
 
        // abajo
 
        if (Pila.top().y < TAMY-1)
        {
            if (Pila.top().y+1 == Destino.y && Pila.top().x == Destino.x) return true;
            if (mat[Pila.top().x][Pila.top().y+1] == 0)
            {
                mat[Pila.top().x][Pila.top().y+1] = 1;
                Pila.push(Cord(Pila.top().x,Pila.top().y+1));
                continue;
            }
        }
 
       // mat[Pila.top().y][Pila.top().x] = 0;
        Pila.pop();
    }
 
    return false;
}

NOTA: Uso ceros en vez de ' '.

En C++ el this se escribe igual.

conio no es estandar ni windows.h

¿Por que dices que es independiente del SO? Yo ahí veo la windows.h y la conio.h.

Para resolver el problema de la portabilidad necesitas compilación condicional:
http://foro.elhacker.net/programacion_cc/duda_sobre_portabilidad-t393915.0.html

El tema de los argumentos infinitos es un poco polémico. Si te da igual el método empleado puedes usar un array de punteros void*, aquí un ejemplo de uso en una implementación de printf:

#include <stdio.h>
 
void Printf(const char* texto,void* args[]);
 
int main()
{
    void* argumentos[3];
    int a = 0;
    float b = 3.2;
    char c = 'e';
 
    argumentos[0] = &a;
    argumentos[1] = &b;
    argumentos[2] = &c;
 
    Printf("Texto: %d  %f  %c",argumentos);
    return 0;
}
 
void Printf(const char* texto,void* args[])
{
    int argumento = 0;
    int i;
    for (i = 0;texto[i];i++)
    {
        if (texto[i] != '%') putchar(texto[i]);
        else
        {
            if (texto[i+1] == '\0'){putchar('%'); return;}
 
            switch (texto[i+1])
            {
            case 'd':
                    {
                        int aux = *((int*)args[argumento]);
                        printf("%d",aux);
                        argumento++;
                        i++;
                        break;
                    }
            case 'f':
                    {
                        float aux = *((float*)args[argumento]);
                        printf("%f",aux);
                        argumento++;
                        i++;
                        break;
 
                    }
            case 'c':
                    {
                        char aux = *((char*)args[argumento]);
                        printf("%c",aux);
                        argumento++;
                        i++;
                        break;
                    }
            default:    putchar('%');
            }
        }
    }
}

Me refiero:

void quickSort(vector<int>& v, int l = 0, int r = v.size()-1);

O bien usar un metodo lanzadera:

void quickSort(vector<int>& v)
{
    quickSort(v,0,v.size()-1);
}

Lo digo para asegurarte de que está bien inicializado.

En efecto, pero eso es en C.

Ni "forzado" ni "automatico", en C no habia ningun sistema para controlar que no adcedieras a posiciones erroneas. Ahi trabajas sabiendo la longitud del array (salvo en el caso de cadenas, que se ponia un cero en el ultimo elemento para acabar).

Bueno ni en C++ hay un sistema. Las razones de esto son puramente por eficiencia, es un desperdicio de recursos ir comprobando si adcedes a una posicion erronea cada vez. De modo que si lo haces, no da error de compilacion y sus consecuencias son indeterminadas (puede que modifiques a otras variables, puede que te de un error de ejecución...).

Los compañeros de arriba te han respondido usando la clase vector. Una objeto que contiene un array que puedes redimensionarlo a tu gusto, ese objeto ademas tiene control sobre su tamaño y podemos consultarlo con el metodo size().

Realmente a la hora de controlarlo no hay mucha diferencia: Su tamaño. Si adcedemos a posiciones invalidas dara error de ejecucion.

¿Estenografía en ficheros? ¿Dependerá del formato del fichero en cuestión no? La idea es buscar los fallos del formato en cuestión.

El de archivos rar es una implementación en C++ de esta técnica:
http://neobits.net/NeobitsOrg/560.html

Cuando se te quede pillado un programa, mata el proceso desde el administrador de tareas (control+alt+supr).

Desactiva los antivirus por si estuvieran metiendo las narices.