Un saludo a todos, solo tengo una pequeña duda, tengo un codigo de arboles B, pero necesito modificar el orden del arbol B, o sea cuantos subarboles puede tener pero en el codigo el orden es una constante para crear el arreglo, y me da error al intentar modificar porque esta declarada como una constante, en fin lo que necesito es modificar esa variable de modo que el usuario defina el orden aqui la parte del codigo

#include <stdio>
 #include <stdlib>
 #include <conio>
 
 #define MAX_LONG 90
 #define ARRIBA 72
 #define ABAJO 80
 #define ENTER 13
 
 const int M=5;//aqui necesito modificar durante la ejecucion del programa
                         // pero me da error si solo la declaro como una variable no
                          // constante por lo del arreglo de claves que esta en la
                         //estructura del nodo
 struct nodo
 {
   int n; // n < M n? de claves en el nodo siempre ser? menor que el orden del B tree
   int arreglo_claves[M-1]; //arreglo de claves
   struct nodo *p[M]; // (n+1 punteros que van a ser usados
 }*root=NULL;//la raiz lo inicializamos en NULL

una constante, por definición, no puede ser modificada durante la ejecución del programa... en caso contrario no sería "constante".

Si necesitas cambiar ese valor de forma dinámica, tienes que usar, por definición, memoria dinámica. La memoria dinámica se reserva como te ha comentado El Benjo, es decir, usando malloc o calloc para reservar la memoria y free para liberarla.

El proceso en sí es sencillo:

1. Modifica tu estructura para poder hacer reservas dinámicas de memoria:

struct nodo
 {
   int n; // n < M n? de claves en el nodo siempre ser? menor que el orden del B tree
   int *arreglo_claves; //arreglo de claves
   struct nodo **p; // (n+1 punteros que van a ser usados
 };

2. Crea una función que te permita hacer las reservas de memoria:

struct nodo* NuevoNodo( int n, int M )
{
  struct nodo* nuevo_nodo = (struct nodo*)malloc( sizeof( struct nodo ) );
  nuevo_nodo->arreglo_claves = (int*)calloc( M - 1, sizeof( int ) );
  nuevo_nodo->p = (struct nodo**)calloc( M, sizeof( struct nodo* ) );
 
  return nuevo_nodo;
}

La diferencia entre malloc y calloc es que calloc pone todos los bits a 0, malloc deja la memoria con los datos que tuviese previamente ( basura ).

3. Estaría bien tener una función que permita liberar toda esa memoria.

En este caso te hace falta un free por cada malloc o calloc... esta parte te la dejo a tí.

4. Usa variables con sentido, M y n no significan absolutamente nada.

Si para programar decides usar este tipo de terminologías, más te vale no olvidar nunca las variables utilizadas para cada algoritmo y tener siempre presente qué algoritmo estás editando en cada momento.

Si en vez de 'M', te encuentras 'max_claves_nodo', y en vez de 'n' tienes 'max_ramas', por ejemplo, de seguro que nunca te confundirás al identificar dichas variables... ni tu ni nadie que pase por ese código.

Por cierto, tal y como está modelada tu estructura, 'n' no significa "máximo de ramas", sino "número actual de ramas". Básicamente es así porque mientras ( n < M ), podré añadir ramas nuevas e incrementar 'n' y el sistema seguirá funcionando... si 'n' fuese un máximo no podría incrementarlo.

Ese matiz es importante y da idea de que usar caracteres sueltos para poner nombres a variables no suele ser una buena idea.