Para listar los archivos lo hacés con llamadas al sistema o con alguna librería.
Por ejemplo podés usar filesystem de Boost. Son multiplataforma.
Sería algo así:

#include <iostream>
#include <boost/filesystem.hpp>
#include <cstdio>
int main(){
	boost::filesystem::path directorio( "./" ); // directorio actual
	boost::filesystem::directory_iterator final;
	boost::filesystem::directory_iterator it( directorio ); // puntero a los archivos del directorio
	while( ++it != final ){
		std::cout << it->path().leaf() << std::endl; }
	return 0;
}

Con esto recorres un directorio especificado y mostras los nombres de los archivos.
Para renombrarlos podés usar rename, que está en cstdio:

rename( "cristian.jpg", "archivo_renombrado.jpg" );

Hola xkiz. Dirent no viene con VC, viene con las librerías para posix. Pero podés probar con esta: http://www.softagalleria.net/dirent.php

Aca algunos otros links:
http://www.cplusplus.com/forum/general/24645/
http://stackoverflow.com/questions/5530933/dirent-h-in-visual-studio-2010-or-2008
http://en.wikipedia.org/wiki/Dirent.h

Para el primer programa tendrías que poner un for dentro de otro. Si querés que el rectángulo tenga un "hueco" podés hacerlo así:

// ingresar valores de base y altura
for( short a = 0; a < altura; a++ ){
	for( short b = 0; b < base; b++ ){
		if( a == 0 || a == altura-1 ) printf("$");
		else if( b == 0 || b == base-1 ) printf("$");
		else printf(" "); // muestra un espacio
	}
	printf( "\n" );
}

---

Para el segundo problema podés inicializar el mínimo, el máximo y la media con el primer número que ingrese el usuario:

printf("Cuantos numeros va ingresar: \n");
scanf( "%f",&cantidad );
 
printf("Ingrese sus numeros: \n");
scanf( "%f", &numero );
 
minimo = maximo = media = numero;
contador = 1;
 
for( int a = 1; a < cantidad; a++ ){ // el primer numero ya se ingreso
	scanf( "%f", &numero );
	media += numero;
	contador++;
	if( numero < minimo ) // nuevo minimo
	if( numero > maximo ) // nuevo maximo
}
 

Y tratá de usar nombres de variables más representativas.

Cambia esta parte:

Nodo *aux;
aux = malloc( sizeof( Nodo ) );

Por esto:

Nodo *aux;
aux = ( Nodo* )malloc( sizeof( Nodo ) );

En cuanto al cero no veo por qué no debería funcionar. Escribinos el mensaje de error.

Hola ginny1685. Por empezar tenés varios errores básicos:

swith( c ) {

Debería ser:

switch( c ) { // falta una letra C 

En este código:

case "\n"
case "\0"
case "\13"

Faltan los dos puntos de cada case y seguramente querés agregarles un break porque sino pasa de largo. Además de que lleva comillas simples, porque comparás un solo carácter.

case '\n':
     // hacer cosas
break;
case '\0':
     // hacer cosas
break;
case '\13':
     // hacer cosas
break;

Tenés dos tipos de aplicaciones:

Aplicaciones de consola: En las que generalmente se limpia pantalla con una llamada a system.
También está clrscr, pero no es una función estándar, sino una función de una librería del compilador Turbo c++.

Aplicaciones gráficas: Los videojuegos ( y cualquier programa ) con gráficos usan librerías gráficas y cada uno maneja la pantalla de acuerdo a esas librerías, pero no hay un Limpia pantallas genérico.

Compilé tu código y la mayoría de los errores eran por la letra Ñ. Luego en la definición de la clase moto faltaba un punto y coma.

Y en estas líneas el último argumento que se le pasa al constructor de vehiculo tiene que ser simplemente "c" y no "*c".

moto::moto(int veloInicial,int liInicial, int capDepoInicial, int anioInicial,  int cilinInicial,const char* c,  const char *c1):
vehiculo( veloInicial,  liInicial,  capDepoInicial, anioInicial, c)

Aca está el código comentado:

#include<iostream>
#include<cstring>
using namespace std;
//Declaracion clase VEHICULO
class vehiculo
{
protected:
	char *cad;
	int litros;
	int kphMas;
	int kphMenos;
	int veloActual;
	int capaDepo;
	int año; // Error por la letra Ñ
	int capDepo;
	int liDepo;
public:
	vehiculo(int veloInicial, int liInicial, int capDepoInicial, int anioInicial, const char *c); // Error por la letra Ñ
	~vehiculo();
	void imprimir();
	void llenarDepo();
	void acelerar(int kphMas);
	void frenar(int kphMenos);
	char *leer(char *c);
};
 
//Declaracion derivada MOTO
class moto : public vehiculo
{
protected:
	int cilindrada;
	int cilinInicial;
	char *tipo;
public:
	moto(int veloInicial,int liInicial, int capDepoInicial, int anioInicial,  int cilinInicial, const char* c, const char *c1); // Error por la letra Ñ
	~moto();
	char* leer1(char*c1);
}; // Faltaba el punto y coma
 
//Constructor VEHICULO
vehiculo::vehiculo(int veloInicial, int liInicial, int capDepoInicial, int anioInicial, const char *c) // Error por la letra Ñ
{
	veloActual = veloInicial;
	liDepo = liInicial;
	capDepo = capDepoInicial;
	año = anioInicial; // Error por la letra Ñ
	cad = new char[strlen(c)+1];
	strcpy(cad, c);
 
}
 
//Destructor VEHICULO
vehiculo::~vehiculo()
{
	delete [] cad;
}
 
//Metodo leer VEHICULO
char *vehiculo::leer(char* c)
{
	strcpy(c, cad);
	return c;
}
 
// Metodo llenar deposito  VEHICULO
void vehiculo::llenarDepo()
{
	cout << "Estas llenando el deposito..." << endl;
	for(; liDepo < capDepo; liDepo++)
	{
	}
	cout << "El deposito esta lleno: " << liDepo<< " Litros."<< endl << endl;
}
 
// Metodo imprimir VEHICULO
void vehiculo::imprimir()
{
	cout << "La velocidad actual es: "<< veloActual << endl;
	cout << "El año del coche es: " << año << endl; // Error por la letra Ñ
	cout << "En el deposito hay: " << liDepo << endl;
	cout << "El nombre del propietario es: " << *cad <<endl << endl;
}
 
// Metodo acelerar VEHICULO
void vehiculo::acelerar(int kphMas)
{
	if(liDepo > 0)
	{
		cout << "Estas acelerando!" << endl;
	    veloActual = veloActual + kphMas;
	    liDepo = liDepo - kphMas / 10;
	    cout << "Su velocidad actual es: " << veloActual << endl;
	    cout << "Su deposito actual es: " << liDepo << endl << endl;
	}
	else
	{
		cout << "El deposito esta vacio!" << endl << endl;
	}
}
 
// Metodo frenar VEHICULO
void vehiculo::frenar(int kphMenos)
{
	if( veloActual - kphMenos > 0)
	{
		cout << "Estas frenando!" << endl;
		veloActual = veloActual - kphMenos;
		cout << "Su velocidad actual es: " << veloActual << endl << endl;
	}
	else
	{
		veloActual = 0;
		cout << "Ya estas parado!" << endl << endl;
	}
}
 
// Constructor MOTO
moto::moto(int veloInicial,int liInicial, int capDepoInicial, int anioInicial,  int cilinInicial,const char* c,  const char *c1): // Error por la letra Ñ
vehiculo( veloInicial,  liInicial,  capDepoInicial, anioInicial, c) // Error por la letra Ñ
{
	veloActual = veloInicial;
	liDepo = liInicial;
	capDepo = capDepoInicial;
	año = anioInicial; // Error por la letra Ñ
	cad = new char[strlen(c)+1];
	strcpy(cad, c);
	cilindrada = cilinInicial;
	tipo = new char[strlen(c1)+1]; // habia una "m" al comienzo
	strcpy(tipo, c1);
}
 
// Destructor Moto
moto::~moto()
{
	delete [] tipo;
}
 
// Metodo leer MOTO
char *moto::leer1(char* c1)
{
	strcpy(c1, tipo);
	return c1;
}
 
int main(){
	return 0;
}
 

expresion.clear();

No sirve para vaciar la variable, sino para vaciar el estado de error.
Para esto hacé lo siguiente:

expresion.str( "" );

Después, yo siempre creo que está muy mal usar funciones/métodos void. Algún valor deberías retornar, y más cuando estás tratando con archivos. Por ejemplo, deberías validar que se haya abierto el archivo primero:

f.open ( "programar.txt", ifstream::in );
if( !f.good ){
     cout << "Error abriendo el archivo." << endl;
     return false;
}
while ( !f.eof() ){
     // hacer cosas
}

En cuanto al resto, trata de no usar tantos whiles. Del archivo de texto que abrís deberías tomar letra por letra hasta encontrar un espacio. En ese punto almacenas los valores que necesites, y continuas tomando caracteres.

La definición es así:

static string MenssageArrival(unsigned int uInt_ID, string Str_Msg); // dentro de la clase
string Game::MenssageArrival(unsigned int uInt_ID, string Str_Msg){ // fuera de la clase
	string retorno;
	return retorno;
}

Si querés manipular las variables miembro de la clase creo que sería mejor pasarle un puntero del objeto que estás usando, en lugar de pasarle el método.

Ah ! Ahora sí tiene sentido !.

Te faltó poner static en el método MenssageArrival.
Ese código quedaría así:

#include<iostream>
using namespace std;
 
class ServerDosGame{
	public:
		string (*fMsg)(unsigned int uInt_ID, string Str_Msg); 
		ServerDosGame( unsigned int & NumberOfPlayers, unsigned int & uInt_StateGame, string (FuncOfMsg)(unsigned int uInt_ID, string Str_Msg) ){
			fMsg = FuncOfMsg;
		}
};
 
class Game{
	public:
		unsigned int uInt_NumberOfPlayers, uInt_StateGame;
		ServerDosGame *Server;
 
		// string MenssageArrival(unsigned int uInt_ID, string Str_Msg){
		static string MenssageArrival(unsigned int uInt_ID, string Str_Msg){ // Debería ser así
			string retorno;
			return retorno;
		}
 
		int run(){
			Server = new ServerDosGame(uInt_NumberOfPlayers, uInt_StateGame, MenssageArrival);	
			return 1;			
		}
};
 
int main( int argc, char **argv ){
	Game *game = new Game();
	return game->run();
}

Static es para poder acceder al método sin declarar una instancia de la clase. Ahora reparando en el código original te debería compilar bien.