Que tal gente resulta que ando haciendo un programa para llenar, sumar, multiplicar, sacar el prom,etc. y cuando intento llenar los datos con sus columna y filas al finalizar antes de entrar al menú me saca del programa, me ayudan?

#include<iostream>
#include<conio2.h>
#include<stdio.h>
 
using namespace std;
//parametrización
void LLENAR_f(int [3][100],int ,int ,int );
void SUAMAR_f(int [3][100]);
void MULTIPLICAR_f(int [3][100]);
void REDIMENCIONAR_f(int [3][100]);
void PROM_FILA_f(int[3][100]);
void CANTIDAD_IMPARES_f(int [3][100]);
 
int main()
{   
    int MDlistrip[3][100]={0};
    float R[3][100]={0};
    int NF,NC,ND;
    short op;
    cout<<"\nIngrese numero de Filas";
    cin>>NF;
    cout<<"\nIngrese numero de Columnas";
    cin>>NC;
    cout<<"\nIngrese numero de Datos";
    cin>>ND;
    LLENAR_f(MDlistrip,NF,NC,ND);
    do
    { 
        gotoxy(15,1);
        cout<<"Menu Principal";
        cout<<"\nSumar dos matrices dispersas 1:"; 
        cout<<"\nMultiplicar dos matrices dispersas 2:"; 
        cout<<"\nEncontrar la traspuesta de ambas matrices dispersas 3:"; 
        cout<<"\nMostrar el promedio de cada fila 4:"; 
        cout<<"\nMostrar la cantidad de impares de cada columna 5:";
        cout<<"\nMostrar las matrices dispersas 6:";  
        cout<<"\nIngrese dato del menu:"; 
        cin>>op; 
        switch(op) 
        { 
            case 1 : SUAMAR_f(MDlistrip) ;break; 
            case 2 : MULTIPLICAR_f(MDlistrip);break; 
           // case 3 : TRASPUESTAS_f();break; 
            case 4 : PROM_FILA_f(MDlistrip);break; 
            case 5 : CANTIDAD_IMPARES_f(MDlistrip);break;
            case 6 : ;break;  
        } 
     }while(op>=1||op<=6);
    system("PAUSE");
 
    return EXIT_SUCCESS;
}
 
void LLENAR_f(int MDlistrip[3][100],int NF,int NC,int ND)
{
     float dat;
     int f,c;
     short i,j;
     MDlistrip[0][0]=NF;
     MDlistrip[0][1]=NC;
     MDlistrip[0][3]=ND;
     for(i=1;i<=MDlistrip[0][3]+1;i++)
     {
            cout<<"\nIngrese Filas";
            cin>>MDlistrip[i][0];
            cout<<"\nIngrese Columnas";
            cin>>MDlistrip[i][1];
            cout<<"\nIngrese Dato";
            cin>>MDlistrip[i][2];  
     }
}
void SUAMAR_f(int MDlistrip[3][100])
{
    int MDlistripB[3][100]={0};
    int MDlistripR[3][100]={0};
    int NF,NC,ND;
    short k=1;
    cout<<"\nIngrese numero de Filas de la matriz B";
    cin>>NF;
    cout<<"\nIngrese numero de Columnas de la matriz B";
    cin>>NC;
    cout<<"\nIngrese numero de Datos de la matriz B";
    cin>>ND;
    LLENAR_f(MDlistripB,NF,NC,ND);
    while ((k<= MDlistripB[0][2]+1)&&(k<=MDlistrip[0][2]+1))
    {
          if((MDlistripB[k][0]==MDlistrip[k][0])&&(MDlistripB[k][1]==MDlistrip[k][1]))
          {
             MDlistripR[k][0]=MDlistrip[k][0];
             MDlistripR[k][0]=MDlistrip[k][0];
             MDlistripR[k][2]=MDlistrip[k][2]+MDlistripB[k][2];
             k++;
          }
          else
          {
              if(MDlistrip[k][0]<MDlistripB[k][0])
              {
                   MDlistripR[k][0]=MDlistripB[k][0];
                   MDlistripR[k][0]=MDlistripB[k][1];
                   MDlistripR[k][0]=MDlistripB[k][2];
                   k++;
                   MDlistripR[k][0]=MDlistripB[k][0];
                   MDlistripR[k][0]=MDlistripB[k][1];
                   MDlistripR[k][0]=MDlistripB[k][2];
                   k++;
              }
              else if (MDlistrip[k][0]>MDlistripB[k][0])
              {
                   MDlistripR[k][0]=MDlistripB[k][0];
                   MDlistripR[k][0]=MDlistripB[k][1];
                   MDlistripR[k][0]=MDlistripB[k][2];
                   k++;
                   MDlistripR[k][0]=MDlistripB[k][0];
                   MDlistripR[k][0]=MDlistripB[k][1];
                   MDlistripR[k][0]=MDlistripB[k][2];
                   k++;
              }
          }
 
    }
}
void MULTIPLICAR_f(int MDlistrip[3][100])
{
    int MDlistripB[3][100]={0};
    int MDlistripR[3][100]={0};
    int NF,NC,ND;
    short k=1;
    cout<<"\nIngrese numero de Filas de la matriz B";
    cin>>NF;
    cout<<"\nIngrese numero de Columnas de la matriz B";
    cin>>NC;
    cout<<"\nIngrese numero de Datos de la matriz B";
    cin>>ND;
    LLENAR_f(MDlistripB,NF,NC,ND);
    if ((MDlistripB[0][0]==MDlistripB[0][0])&&(MDlistripB[0][0]==MDlistripB[0][0]))
    {
        if((MDlistripB[k][0]==MDlistrip[k][0])&&(MDlistripB[k][1]==MDlistrip[k][1]))
          {
             MDlistripR[k][0]=MDlistrip[k][0];
             MDlistripR[k][0]=MDlistrip[k][0];
             MDlistripR[k][2]=MDlistrip[k][2]*MDlistripB[k][2];
             k++;
          }
          else
          {
 
          }
    }
    else
    {
        cout<<"\nNo se puede multiplicar las matrices";
    }
}
void REDIMENCIONAR_f(int MDlistripR[3][100])
{
     int k;
     float aux[3][100];
     for (k=0;k<=(MDlistripR[0][2]+1);k++)
     {
         aux[k][0]=MDlistripR[k][0];
         aux[k][1]=MDlistripR[k][1];
         aux[k][2]=MDlistripR[k][2];
     }
}
 
 
void PROM_FILA_f(int MDlistrip[3][100])
{
     int f;
     short i,k;
     float prom,ac=0;
     cout<<"\nQue fila desea sacar el promedio?:\t";
     cin>>f;
     for (i=1;i<=(MDlistrip[0][2]+1);i++)
     {
         if(MDlistrip[i][0]=f)
         {
             for(k=i;k<=f;k++)
             {
                ac=ac+MDlistrip[i][2];
             }
 
         }
     }
     prom=ac/MDlistrip[0][1];
     cout<<prom;
}
 
void CANTIDAD_IMPARES_f(int MDlistrip[3][100])
{
     int c, ac=0;
     short i,k;     
     cout<<"\nQue columna quiere ver impares?:\t";
     cin>>c;
     for (i=1;i<=(MDlistrip[0][2]+1);i++)
     {
         if(MDlistrip[i][1]=c)
         {
             for(k=i;k<=c;k++)
             {
                if(MDlistrip[k][2] %2 !=0 )
                {
                    ac=ac+1;
                }
             }
 
         }
     }
     cout<<"\nHay",ac,"impares en la columna",c;
 
}
void MOSTRAR_f(int MDlistrip[3][100])
{
     short k;
     for (k=0;k<=(MDlistrip[0][2]+1);k++)
     {
         cout<<MDlistrip[k][0],"\n";
         cout<<MDlistrip[k][1],"\n";
         cout<<MDlistrip[k][2],"\n";
 
     }
}
 

* Si usas C++ no pongas includes de C ( los que acaban en .h) y más aún si estos includes no son necesarios.

* Deberías utilizar el mismo tipo de dato en las diferentes matrices:

void REDIMENCIONAR_f(int MDlistripR[3][100])
{
     int k;
     float aux[3][100];
     for (k=0;k<=(MDlistripR[0][2]+1);k++)
     {
         aux[k][0]=MDlistripR[k][0];
         aux[k][1]=MDlistripR[k][1];
         aux[k][2]=MDlistripR[k][2];
     }
}

Ahí recibes una matriz de tipo int y la copias en... una matriz de tipo float?? además, aux se pierde una vez sales de la función. Esta función por ejemplo no hace nada productivo.

* La definición de matriz es valores=cifras*columnas. Dicho esto, no tiene ningún sentido el tratamiento que le das en partes del código como:

    cout<<"\nIngrese numero de Filas";
    cin>>NF;
    cout<<"\nIngrese numero de Columnas";
    cin>>NC;
    cout<<"\nIngrese numero de Datos";
    cin>>ND;

o:

 for(i=1;i<=MDlistrip[0][3]+1;i++)
     {
            cout<<"\nIngrese Filas";
            cin>>MDlistrip[i][0];
            cout<<"\nIngrese Columnas";
            cin>>MDlistrip[i][1];
            cout<<"\nIngrese Dato";
            cin>>MDlistrip[i][2];  
     }

Si tu programa maneja dos matrices deberías diseñar una estructura que gestione la matriz y utilizarla para manejar las dos matrices. No se, algo tal que:

struct Matriz
{
  int filas;
  int columnas;
  int* datos;
};
 
// Sin memoria dinámica
struct Matriz2
{
  int filas;
  int columnas;
  int datos[MAX_FILAS][MAX_COLUMNAS];
 

O, si quieres aprovechar un poco las capacidades de programación orientada a objetos:

class Matriz
{
  public:
    Matriz( int filas, int columnas );
 
    ~Matriz( );
 
    void SetDato( int fila, int columna, int dato );
 
    int Dato( int fila, int columna ) const;
 
    int Filas( ) const;
 
    int Columnas( ) const;
 
  private:
 
    int _filas;
    int _columnas;
 
    // Esta se puede sustituir por una matriz fija para evitar el uso de memoria dinamica
    int* _datos;
};

Tú estás creando una matriz de una forma muy extraña que no te garantiza celdas duplicadas o inexistentes y que, además, no te permite trabajar con dos matrices para hacer las operaciones básicas.

En serio, no termino de entender por qué generas una terna( fila, columna, dato ). ¿Qué sucede si el usuario repite los valores de fila y columna? ¿Y si hay una dupla fila-columna que se olvida de indicar? ¿Y si tengo, por ejemplo, una matriz de 2x2 e intento rellenar un dato de la fila 4, columna 20? ¿Y si indico una fila / columna negativa?

El modelo que propones es demasiado propenso a errores y es bastante complejo de gestionar y de usar. Hay formas mucho más sencillas:

#include <iostream>
 
#define MAX_FILAS 20
#define MAX_COLUMNAS 20
 
struct Matriz
{
  int filas;
  int columnas;
  int datos[MAX_FILAS][MAX_COLUMNAS];
 
  Matriz( ) : filas( 0 ), columnas( 0 )
  { }
};
 
Matriz Sumar( const Matriz& matriz1, const Matriz& matriz2 )
{
  Matriz resultado;
 
  if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
  {
    resultado.filas = matriz1.filas;
    resultado.columnas = matriz1.columnas;
 
    for ( int i=0; i<resultado.filas; i++ )
    {
      for ( int j=0; j<resultado.columnas; j++ )
        resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
    }
  }
 
  return resultado;
}
 
void Imprimir( const Matriz& matriz )
{
  for ( int i = 0; i < matriz.filas; i++ )
  {
    for ( int j = 0; j < matriz.columnas; j++ )
      std::cout << matriz.datos[ i ][ j ] << " ";
 
    std::cout << std::endl;
  }
}
 
int main( )
{
  Matriz matriz1, matriz2;
 
  matriz1.filas = 2;
  matriz1.columnas = 2;
 
  for ( int i=0; i<matriz1.filas; i++ )
  {
    for ( int j=0; j<matriz1.columnas; j++ )
      matriz1.datos[ i ][ j ] = j - i;
  }
 
  matriz2.filas = 2;
  matriz2.columnas = 2;
  for ( int i=0; i<matriz1.filas; i++ )
  {
    for ( int j=0; j<matriz2.columnas; j++ )
      matriz2.datos[ i ][ j ] = 2* i + j;
  }
 
  // Sumamos las matrices
  if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
  {
    Matriz resultado;
    resultado.filas = matriz1.filas;
    resultado.columnas = matriz1.columnas;
 
    for ( int i=0; i<resultado.filas; i++ )
    {
      for ( int j=0; j<resultado.columnas; j++ )
        resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
    }
  }
 
  Matriz resultado = Sumar( matriz1, matriz2 );
 
  std::cout << "Matriz1:" << std::endl;
  Imprimir( matriz1 );
 
  std::cout << "Matriz2:" << std::endl;
  Imprimir( matriz2 );
 
  std::cout << "Resultado:" << std::endl;
  Imprimir( resultado );
  return 0;
}

Aún así, insisto, queda mejor con clases que con estructuras... pero creo que es preferible que te manches un poco las manos y no dártelo todo hecho