ofstream no dispone de constructor copia. Carece de dicho constructor porque ofstream es un buffer de escritura y, al hacer uso del constructor copia, podrías tener dos ofstream distintos apuntando al mismo fichero. Si eso llega a suceder se podrían provocar inconsistencias en el fichero.

Dicho esto tienes dos opciones, o la solución propuesta por BlackM4ster o usar un puntero para referenciar la instancia de ofstream.

Depende del baremo en que te bases a la hora de definir una optimización:

* Si para ti optimizar es reducir el código de la función, perfecto, esta función es más óptima.
* Si optimizar es sinónimo de velocidad, has de saber que una función recursiva es más lenta que un bucle. Además la recursividad, a diferencia de los bucles, tiene un límite dado por la pila... si te pasas el programa casca.

Con esto no intento desmerecer el ejemplo de do-while, el cual funciona perfectamente, sino comentarte los riesgos de aplicar recursividad a todo.

Además, ten en cuenta que este ejemplo no usa aritmética de punteros.

double p[MAX][1];

Esta declaración no tiene demasiado sentido. Si pretendes almacenar dos números en cada posición de "p" tienes que declarar la variable así:

double p[MAX][2];

De esta forma, para cada p dispones de dos espacios, uno para cada numero.

Ahora vamos con las cadenas:

char nombre[MAX];

Esta declaración está mal. Las cadenas de caracteres no se usan exactamente igual que el resto de "tipos nativos". Me explico:

Si intentas almacenar "hola" en C necesitas (al menos) 5 bytes de memoria... si en cambio intentas almacenar "mensaje", la cantidad de memoria requerida asciende a 8 bytes. En cambio, en un int todos los números van a ocupar 4 bytes... ya estés almacenando el 0 o el 5.234.045.

Dicho esto, cada cadena de caracteres es, como su propio nombre indica, una secuencia de tipo "char". Esto quiere decir que "char nombre[MAX]" únicamente te va a permitir almacenar una cadena de caracteres... cuya longitud máxima será MAX-1. Si tu idea es poder almacenar MAX cadenas de caracteres diferentes la declaración debería quedar así:

char nombre[MAX][20];

Esto suponiendo que cada "nombre" no vaya a ocupar más de 19 caracteres.

Si miramos ahora el bucle for, tenemos:

for(i=0;i<n;i++)
    fscanf(txt,"%s %lf %lf",&nombre[MAX],&p[i][0],&p[i][1]);

Esto, como bien has indicado, está mal. Aplicando los cambios que hemos comentado anteriormente, este bucle debería lucir más o menos así:

for(i=0;i<n;i++)
    fscanf(txt,"%s %lf %lf",&nombre[i],&p[i][0],&p[i][1]);

Fíjate que ha desaparecido toda referencia a "MAX", lo cual tiene sentido, ya que intentamos guardar cada nombre en una posición diferente.

Consejos finales:

* Deberías validar que "n" se encuentra dentro del rango [1..13], ya que si te da por poner una cantidad superior vas a escribir en memoria que no te pertenece y eso te va a dar problemas.

* Deberías poner a las variables nombres con significado propio, "p" o "n" no dicen absolutamente nada y eso dificulta la lectura del código.

* Deberías tabular el código con criterio, mejoras la legibilidad del código.

Un saludo.

Eso es porque tu algoritmo de ordenación no funciona.

Te lo pongo con un ejemplo práctico... si tu tienes: 1  4  2  5  3  7  6  9  8  10.

Incialmente comparas 1 y 10... orden correcto, después comparas 4 y 8... orden correcto, después comparas 2 y 9... nuevamente orden correcto... al final no has cambiado ningún valor de posición.

Lo que te están pidiendo es que implementes el algoritmo de la burbuja, el de toda la vida. La "novedad" que plantea tu ejercicio es que tiene que poderse elegir si empiezan por el principio del array o por el final... pero no te están pidiendo que pongas un puntero al principio, otro al final y que vayas comparándolos entre ellos.

No se si me explico.

void Ordenar(int*, int, bool);
 
// ...
 
Ordenar(lista, 10, 0);

Los valores válidos para los booleanos son "true" y "false", acostúmbrate a usar esos valores en vez de 1 y 0.

Ordenar(lista, 10, false);

aunque también te puedes plantear el uso de enums:

enum TipoOrden
{
  Ascendente,
  Descendente
};
 
void Ordenar(int *, int , TipoOrden );
 
int main( )
{
  // ...
  Ordenar( lista, 10, Ascendente );
  // ...
}
 
void Ordenar(int *vector, int nElementos, TipoOrden tipoOrden )
{
  // ...
 
  if ( tipoOrden == Ascendente )
  {
  // ...
 

Además, en cuanto EI pase por aquí te va a cerrar el hilo.

¿Qué tienes hecho? ¿Qué te falla?

No se hacen tareas y no respondes a ninguna de estas preguntas.

Lo he dicho otras veces, hacer un trabajo es algo que se debería pagar... no es lo mismo resolver una duda que hacer una práctica completa o un trabajo a alguien... pide tu a alguien que te pinte la casa gratis a ver si cuela.

un número, por ejemplo el 10, se codifica en hexadecimal tal que: 00 00 00 0A. El 20.000 se codifica tal que: 00 00 4E 20. Es decir, un int SIEMPRE va a ocupar el mismo número de bits, independientemente de su valor.

Ahora probamos con strings. "Hola" requiere 5 bytes ( 4 para los caracteres y 1 para el caracter nulo de fin de cadena ), "Adios" requiere 6 y "elhacker.net", 13. Como ves, el espacio necesario para poder almacenar una cadena de caracteres depende de la longitud de la misma y esa es la razón por la que las cadenas son SIEMPRE punteros.

Un string en C puede quedar definido tal que:

char cadena[20]; // Longitud máxima de la cadena: 19

Con esto te respondo a tu segunda pregunta... NO, no tienen que ser arrays bidimensionales.

Si necesitas almacenar un nombre y una descripción puedes hacerlo tal que...

char cliente[ 20 ];
char descripcion[ 20 ];

... por ejemplo.


Lo que si te digo es que tu profesor no debería obligarte a usar conio... pero eso allá cada uno.

¿Y la aritmética de punteros donde queda?

Tratando el tema dejado por ivancea96, tal y como está planteado el enunciado no tiene ningún sentido hacer un código más genérico por varias razones:

* Únicamente las cadenas de caracteres tienen la obligación de terminar con caracter nulo.
* La función no admite un segundo parámetro que permita identificar el final de la cadena.

Si se dispusiese de información adicional y de algo más de flexibilidad sería fácil hacer una función genérica que calculase el tamaño de un array cualquiera.

compila con C++11.

Si no puedes usar C++11, entonces puedes usar la función atoi heredada de C.