Lo primero que debes indicar es el lenguaje de programacion que estas utilizando, C o C++.

En el caso de C ...

Debes declarar dos arrays. El primero para almacenar los nombres y el segundo para las calificaciones. Ambos son "arrays de arrays" ya que cada uno de sus elementos es a su vez un array, eso porque en el primer caso se deben almacenar cada uno de los caracteres del nombre y el segundo para las seis calificaciones por alumno.

Un programa base seria asi:

#include <stdio.h>
#include <stdlib.h>
 
#define NUM_ALUMNOS        4
#define NUM_NOTAS          6
#define LONG_MAX_NOMBRE  256
 
int main(void)
{
   char nombre[NUM_ALUMNOS][LONG_MAX_NOMBRE];
   double calif[NUM_ALUMNOS][NUM_NOTAS];
 
   /* ... */
 
   return EXIT_SUCCESS;
}

El resto, leer los nombres y calificaciones, te toca a ti (por favor lee las reglas de los foros).

Un saludo

Tres detalles a tener en consideración en tu programa:

1) Este solo funcionara en compiladores que soporten la nueva característica "arrays de longitud variable", esto es parte de C99 (el viejo estandar C90 no lo soporta).

2) En C los indices de los arrays inician en 0 y terminan en N-1 donde N es el numero de elementos en el array. Tu estas utilizando 1 a N y eso no es correcto (el elemento de indice N no existe).

3) Para obtener el promedio debes sumar cada uno de los valores en un acumulador y al final dividir entre el numero de elementos (filas por columnas).

El programa con esas y otras correcciones es:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   int filas;
   int columnas;
   int i;
   int j;
   int total;
 
   printf("Diga el numero de filas: ");
   fflush(stdout);
   scanf ("%d", &filas);
 
   printf("Diga el numero de columnas: ");
   fflush(stdout);
   scanf ("%d", &columnas);
 
   int mat[filas][columnas];
 
   total = 0;
   for (i = 0; i < filas; i++)
      for (j = 0; j < columnas; j++){
         printf("Indica el valor de mat[%d][%d]: ", i, j);
         fflush(stdout);
         scanf("%d", &mat[i][j]);
 
         total += mat[i][j];
      }
 
   printf("Promedio: %.2f\n", (double) total / (filas * columnas));
 
   return EXIT_SUCCESS;
}

Un saludo

Lo primero: en C puedes almacenar el valor de retorno de malloc y para el caso cualquier función que retorne un "void *" en cualquier variable de tipo "puntero a objeto".

Primero debes reservar memoria para el bloque principal que almacenara las direcciones de cada fila. A continuación debes reservar el bloque para cada una de las filas y cuyo tamaño es igual al numero de columnas por el tamaño del objeto almacenado.

Siguiendo el ejemplo que publicas la versión correcta es:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   int **mat;
   int filas = 5;
   int columnas = 30;
   int i;
 
   /* Reserva del bloque principal */
   mat = malloc(filas * sizeof *mat);
 
   /* Reserva de la memoria para cada fila */
   for (i = 0; i < filas; i++)
      mat[i] = malloc(columnas * sizeof *mat[i]);
 
   /* ... Algun proceso ... */
 
   /* Liberamos la memoria de cada fila */
   for (i = 0; i < filas; i++)
      free(mat[i]);
   /* Liberamos el bloque principal */
   free(mat);
 
   return EXIT_SUCCESS;
}

Un saludo

En el caso de MS Windows lo primero que se debe revisar es MSDN, la pagina en cuestión es:

Processes and Threads

Un saludo

No necesariamente.

En C y C++ los "agregados" (estructuras y uniones) permiten utilizar su dirección en memoria como la dirección en memoria de su primer campo (estructuras) o cualquiera de ellos (uniones).

Para ello se debe cumplir con los requisitos de alineación. El significado de esta es simple: se almacena el objeto en una dirección múltiplo de su tamaño.


Para explicarlo mejor los requisitos de alineación de tu unión "casa" deben coincidir con los de todos sus campos, estos son:

1) tipo int (campo "direccion").
2) tipo char[34] (campo "nombre", no hay problema con este).
2) tipo double (campo "pisos").


En tu caso la unión debe almacenarse en una dirección que sea múltiplo de 4 (int) y 8 (double), como puedes imaginarte eso condiciona su tamaño (40 es múltiplo de 4 y 8).

Por supuesto hay que recordar que el tamaño de cada uno de los tipos no esta garantizado (depende de la implementación).

Un saludo

Comentarios subjetivos sobre la notación húngara se pueden encontrar muchos, por ejemplo en la pagina de Charles Petzold. No solo eso, en libros considerados "argumentos de autoridad" hay lineamientos que abren la puerta a todo tipo de discusiones.

Por ejemplo en la biblia de C++ (el libro "The C++ Programing Language") BS recomienda, entre otras cosas, el uso de fuentes proporcionales (y para alinear el texto eso implica el uso de tabuladores en lugar de espacios).

Sin tratar de echarle mas leña al fuego a la discusión en el sentido de "¿cual es mejor?" un documento interesante es:

Making Wrong Code Look Wrong by Joel Spolsky.

Hay que tomarlo de forma objetiva, mente abierta y cada quien sacara sus propias conclusiones.


----


Un cuestionamiento objetivo en contra del uso de nombres como "__pp_back" es el siguiente.

1) Al utilizar nombres de encabezados terminados con ".h" como "<stdio.h>" el nombre de espacios utilizado es el global.

2) En C (y eso incluye las facilidades de su biblioteca estándar) los nombres con un guion bajo inicial están reservados.

Si bien el riesgo de un conflicto de nombres es bajo seria mejor evitarlo ya sea utilizando los nombres "políticamente correctos" como "<cstdio>" o bien evitando los nombres en la forma ya mencionada.


----


En cuanto al programa de BlackZeroX este se puede mejorar, esto por varias razones. La primera es que la variable "__pp_back" solo se utiliza para almacenar el valor de "__pp_vector" sin que ninguna de ellas sea modificada, por ello esa variable se puede eliminar.

De forma similar a free se puede utilizar delete, no es necesario verificar si se pasa un puntero nulo ya que el comportamiento esta garantizado (no pasa nada). Eso nos lleva a eliminar la ultima sentencia condicional.

A la variable "__new_ptr" se le da un valor inicial de NULL, eso nos lleva a eliminar (por superflua) la rama (y asignación) en:

}else 
   __new_ptr = NULL;

Por ultimo un detalle que debo admitir si es subjetivo: al utilizar 0 en lugar de NULL evitamos incluir <cstdio>.

Con esos cambios (mas la nomenclatura al gusto) quedaría así:

#include <cstring>
using std::memcpy;
 
#include <algorithm>
using std::min;
 
void **RedimPreserve(void **buffer, size_t size, size_t new_size)
{
   if (size == new_size)
      return buffer;
 
   void **new_buffer = 0;
   if (new_size > 0) {
      new_buffer = new void *[new_size];
 
      if (size > 0 && buffer != 0)
         memcpy(new_buffer, buffer, min(size, new_size) * sizeof (void*));
   }
 
   delete[] buffer;
 
   return new_buffer;
}
 
int main()
{
   char **msg = NULL;
 
   msg = (char**) RedimPreserve((void**) msg , 00 , 10);
   msg = (char**) RedimPreserve((void**) msg , 10 , 11);
   msg = (char**) RedimPreserve((void**) msg , 11 , 10);
   msg = (char**) RedimPreserve((void**) msg , 10 , 00);
   msg = (char**) RedimPreserve((void**) msg , 00 , 13);
   msg = (char**) RedimPreserve((void**) msg , 13 , 20);
   delete[] msg;
 
   return 0;
}

Un saludo

Para procesar y descartar manualmente el espacio blanco puedes utilizar el manipulador "noskipws", por ejemplo:

#include <iostream>
using std::cout;
using std::endl;
using std::noskipws;
 
#include <fstream>
using std::ifstream;
 
#include <cctype>
using std::isspace;
 
int main()
{
   ifstream entrada("Entrada.txt");
   entrada >> std::noskipws;
 
   bool descartar = false;
   char ch;
   while (entrada >> ch) {
      if (!descartar) {
         if (!isspace(ch) )
            cout << ch;
         else {
            cout << endl;
            descartar = true;
         }
      }
 
      if (ch == '\n')
         descartar = false;
   }
   entrada.close();
 
   return 0;
}

Una mejor opcion como ya indico .:BlackCoder:. es utilizar la funcion miembro "ignore", por ejemplo:

#include <iostream>
using std::cout;
using std::endl;
 
#include <fstream>
using std::ifstream;
 
#include <limits>
using std::numeric_limits;
 
#include <string>
using std::string;
 
int main()
{
   ifstream entrada("Entrada.txt");
   string palabra;
 
   while (entrada >> palabra) {
      cout << palabra << endl;
      entrada.ignore(numeric_limits<int>::max(), '\n');
   }
   entrada.close();
 
   return 0;
}

Un saludo

El programa no va a ejecutarse correctamente debido a las dos variables para las listas de la función principal:

_lista *lista_A;
_lista *lista_B;

No tienen un valor inicial, al no tenerlo inician con un valor no definido.

El error se genera con el primer uso de esas variables, al aplicar indireccion (acceder al objeto apuntado) en la función "iniciaLista"

LISTA->inicio = NULL;
LISTA->fin = NULL;
LISTA->tamano = 0;

En tu programa no necesitas que esas dos variables sean punteros, solo debes declararlas de tipo "struct ListaIdentificar" y pasar su dirección a las funciones que lo requieran mediante el operador "dirección de" (el '&').

Aparte de eso el programa tiene algunas deficiencias como nombres de variables iniciando con el carácter '_' (eso esta reservado), definición de la funcion "main" (deberia ser "int main(void) ..." o bien "int main() ..."), uso de conio (no es necesario), etc.

Por ultimo la función "pertenencia" esta mal implementada, revisa con cuidado que pasa si el valor buscado existe y se encuentra en el ultimo nodo.

El programa con esas y otras correcciones es:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct nodo {
   int valor;
   struct nodo *sig;
};
 
struct lista {
   struct nodo *inicio;
   struct nodo *fin;
   int num_elem;
};
 
void inicializar(struct lista *lista);
void insertar(struct lista *lista, int valor);
void imprimir(struct lista lista);
int buscar(struct nodo *p, int valor);
 
int main(void)
{
   struct lista lista;
   int opc;
   int valor;
 
   inicializar(&lista);
 
   do {
      printf("Ingresa valor a insertar en la lista: ");
      fflush (stdout);
      if (scanf("%d", &valor) != 1)
         return EXIT_FAILURE;
 
      if (!buscar(lista.inicio, valor))
         insertar(&lista, valor);
 
      puts("Ingresar otro valor? (1 ==> si)");
      if (scanf("%d", &opc) != 1)
         return EXIT_FAILURE;
   }while (opc == 1);
 
   imprimir(lista);
   /* Falta liberar la memoria utilizada */
 
   return EXIT_SUCCESS;
}
 
void inicializar(struct lista *lista)
{
   lista->inicio = NULL;
   lista->fin = NULL;
   lista->num_elem = 0;
}
 
void insertar(struct lista *lista, int valor)
{
   struct nodo *nuevo;
   struct nodo *p;
 
   nuevo = malloc(sizeof *nuevo);
   nuevo->valor = valor;
   nuevo->sig = NULL;
 
   if (nuevo != NULL){
      if (lista->inicio == NULL){
         lista->inicio = nuevo;
         lista->fin = nuevo;
         lista->num_elem = 1;
      }else {
         for (p = lista->inicio; p->sig != NULL; p = p->sig)
            ;
 
         p->sig = nuevo;
         lista->fin = nuevo;
         lista->num_elem++;
      }
   }else
      exit(EXIT_FAILURE);
}
 
void imprimir(struct lista lista)
{
   struct nodo *p;
 
   printf("Inicio-> ");
   for (p = lista.inicio; p != NULL; p = p->sig)
      printf("%d -> ", p->valor);
   puts("NULL");
 
   printf("Cardinalidad: %d\n", lista.num_elem);
}
 
int buscar(struct nodo *p, int valor)
{
   while (p != NULL && p->valor != valor)
      p = p->sig;
 
   return p != NULL; /* 1 == existe, 0 == no se encuentra */
}

Falta liberar la memoria utilizada por la lista y agregar la segunda, eso te toca a ti.

Un saludo

Si vas a desarrollar un programa en C debes ajustarte a las facilidades que provee ese lenguaje olvidándote por el momento de las características de ADA y centrándote en el algoritmo, en tu caso este es:

mientras se pueda leer una linea de texto
   procesarla

Eso en C lo puedes implementar utilizando las funciones fopen/fclose para abrir/cerrar el archivo y fgets para leer la linea de texto. Un programa de ejemplo donde el proceso de la linea es simplemente imprimirla en la salida estándar es:

#include <stdio.h>
#include <stdlib.h>
 
#define LONG_MAX_LINEA  256
#define NOM_ARCHIVO  "Entrada.txt"
 
int main(void)
{
   FILE *entrada;
   char linea[LONG_MAX_LINEA];
 
   if ((entrada = fopen(NOM_ARCHIVO, "r")) == NULL){
      perror(NOM_ARCHIVO);
      return EXIT_FAILURE;
   }
 
   while (fgets(linea, LONG_MAX_LINEA, entrada) != NULL)
      fputs(linea, stdout);
 
   fclose(entrada);
 
   return EXIT_SUCCESS;
}

En tu caso este es mas complicado, hay que conocer si el nombre de cada equipo es una sola palabra (por ejemplo "Barcelona") o bien pueden existir nombres con mas de una palabra (por ejemplo "La Coruña").

Formas de separar la linea hay muchas ya que puede basarse en diferentes funciones como strchr, strpbrk, strtok, etc.

Si la estructura del archivo de datos esta garantizada una forma separando las partes en base a una funcion propia es:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define LONG_MAX_LINEA  256
#define NOM_ARCHIVO  "Entrada.txt"
 
struct partido {
   char local[LONG_MAX_LINEA];
   char visitante[LONG_MAX_LINEA];
   int goles_loc;
   int goles_vis;
};
 
struct partido extraer(char const linea[]);
 
int main(void)
{
   FILE *entrada;
   char linea[LONG_MAX_LINEA];
   struct partido p;
 
   if ((entrada = fopen(NOM_ARCHIVO, "r")) == NULL){
      perror(NOM_ARCHIVO);
      return EXIT_FAILURE;
   }
 
   while (fgets(linea, LONG_MAX_LINEA, entrada) != NULL){
      p = extraer(linea);
 
      printf("Local: %s\n", p.local);
      printf("Visitante: %s\n", p.visitante);
      printf("Resultado: %d - %d\n", p.goles_loc, p.goles_vis);
   }
 
   fclose(entrada);
 
   return EXIT_SUCCESS;
}
 
struct partido extraer(char const linea[])
{
   struct partido p;
   char *a;
   char *b;
 
   /* Obtenemos la posicion de " - " */
   a = strstr(linea, " - ");
   sprintf(p.local, "%.*s", a - linea, linea);
 
   /* Obtenemos la posicion de " : " */
   a += 3;
   b = strstr(a, " : ");
   sprintf(p.visitante, "%.*s", b - a,  a);
 
   /* Los goles los extraemos con sscanf */
   sscanf(b + 3, "%d %d", &p.goles_loc, &p.goles_vis);
 
   return p;
}

Pero si hay mas espacio blanco en las lineas se debe modificar la aproximacion para buscar solo los caracteres separadores ('-' y ':' en tu caso).

Un saludo

En el archivo "misfunciones.h" te falta el punto y coma al final de la declaracion de la funcion "suma":

int suma(int a, int b)

Un saludo