hey yo tengo una pregunta...es posible poder hacer las tablas de multiplicar en una matriz....usando punteros?....osea la matriz no tiene ningun dato....sino la muy matriz vacia....la pregunta en si es...tengo que llenar la matriz primero o puedo llenarla por medio de punteros de alguna forma...yo no he podido encontrar ninguna forma...solo llenandola manualmente...
saludos!
se os agradece su colaboracion
les dejare el code que tengo...


#include<conio.h>
#include<iostream.h>

void llenar();
int mostrar();

/************************************************** **/
/*******************INICIO DE MAIN*******************/
/************************************************** **/
main(){//inicio de main

int op;

do{

cout<<"\n*****Matriz Que Muestra Las Tablas de Multiplicar*****";
cout<<"\nDigite la Opcion que desea: ";
cout<<"\n1.LLenar Matriz.";
cout<<"\n2.Mostrar Matriz.";
cout<<"\n3.Salir.\n";
cin>>op;

switch (op){//inicio de Switch

case 1:
cout<<"\nLlenando Tablas...";
llenar();//LLAMADO DE LA FUNCION QUE LLENARA LA TABLA
cout<<"\nPresiona Enter...";
getch();

break;

case 2:
cout<<"\nTabla De Multiplicar.";
mostrar();
getch();

break;

case 3:
cout<<"\nUsted decidio salir...ADIOS!";
getch();
exit(0);

break;
default:
cout<<"\nEsa no es una opcion valida";

}//fin de switch

}while(op=3);


}//fin de main

/********************************************/
/****************FIN DE MAIN*****************/
/*******************************************/

/********************************************/
/************INICIO DE FUNCIONES*************/
/********************************************/

/********************FUNCION LLENAR********************
*****************INICIO FUNCION LLENAR*****************/
/************************************************** ***/

void llenar(){//INICIO DE FUNCION LLENAR
int *puntero;
int tabla[11][11];
int r;
puntero=tabla[1];

for(int i=1;i<=11;i++){//inicio de for i
for(int j=1;j<=11;j++){//inicio de funcion J
r=i*j;

}//fin de funcion J
}//fin de for i

}
/************************************************** */
/****************FIN FUNCION LLENAR*****************/
/************************************************** */


/********************FUNCION MOSTRAR*******************
*****************INICIO FUNCION MOSTRAR****************/
/************************************************** ***/

int mostrar(){
int h;
int k;
int t;
int *ptr;
for(int h=1;h<=11;h++){//inicio de for h
cout<<"\n";
for(int k=1;k<=11;k++){//inicio de funcion k
t=h*k;
cout<<t;
cout<<"\t";
}//fin de funcion h
}//fin de for k


}
/************************************************** */
/****************FIN FUNCION MOSTRAR****************/
/************************************************** *

Si, se puede usar la memoria dinámica, pero que tal llevas los punteros y dobles punteros?

Pero en realidad los punteros sirven mas que nada para no desaprovechar memoria, eligiendo en tiempo de ejecucción la dimensión de la matriz, si sabes su dimensión por qué tanto interes en los punteros?

A ver si encuentro algun ejemplito de los muchos q hice yo para que lo veas.

Saludos; Kira

Este es un ejemplo de arrays de ints sin usar memoria dinámica, pero accediendo a él mediante punteros.

#include <stdio.h>
#include <stdlib.h>
#define MAX 5
void mostrar(int *a[]);
void introducir(int *a[],int v[]);
void main()
{
int *a[MAX],v[MAX];
introducir(a,v);
mostrar(a);
}
void introducir(int *a[],int v[])
{
int i;
for (i=0;i<MAX;i++)
{
printf("Dato: ");
scanf("%d",&v[ i ]);
a[ i ]=&v[ i ];
}
}
void mostrar(int *a[])
{
int i;
for (i=0;i<MAX;i++)
{
printf("%d ",*(*(a+i)));
}
}

Este es un ejemplo con un array bidimensional con memoria dinámica de cadena de caracteres.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//#include <time.h>
int leercadenas(char **pcad,int nfilas);
void ordenarcadenas(char **pcad,int n);
void visualizar(char **pcad, int n);
void main()
{
int nfilas,n;
char **pcad;
printf("Introduzca numero de cadenas: ");
scanf("%d",&nfilas);
fflush(stdin);
if ((pcad=(char **)malloc(nfilas*sizeof(char *)))==NULL)
{
printf("Insuficiente espacio en memoria");
exit(-1);
}
n=leercadenas(pcad,nfilas);
system("cls");
printf("Cadenas desordenadas");
visualizar(pcad,n);
ordenarcadenas(pcad,n);
printf("\n\nCadenas ordenadas");
visualizar(pcad,n);
printf("\n\nBy Kira = She-Devil = NowHere,\n\n");
}
void ordenarcadenas(char **pcad,int n) //ordenas alfabeticamente als cadenas
{
int s=1,i;
char *aux;
// long t=clock();
while (s==1 && --n>0)
{
s=0;
for (i=0;i<n;i++)
{
if (strcmp(*(pcad+i),*(pcad+i+1))>0)
{
aux=*(pcad+i);
*(pcad+i)=*(pcad+i+1);
*(pcad+i+1)=aux;
s=1;
}
}
}
// printf("\n\n%d",t);
}
int leercadenas(char **pcad,int nfilas)
{
int i=0,lon;
char aux[50];
printf("Introduzca cadenas, para finalizar, pulse solo Enter en la nueva cadena\n\n");
printf("Cadena: ");
while (i<nfilas && (lon=strlen(gets(aux)))>0)
{
*(pcad+i)=(char *)malloc(lon+1);//realizas el malloc de la longitud +1 para el '\0'
if (*(pcad+i)==NULL)//miras que el puntero no haya dado fallo de memoria
{
printf("IEM");
exit(-1);
}
strcpy(*(pcad+i),aux);//copias aux en la matriz
i++;//incrementas i
if (i!=nfilas)  //compruebas que no se pase del numero de cadenas pedidas
printf("Cadena: ");
}
return i; //devuelves i
}
void visualizar(char **pcad,int n) //le apsas el puntero y el numero de cadenas
{
int i;
for (i=0;i<n;i++)
{
printf("\n%s",*(pcad+i)); //visualizas las cadenas
}
puts("");
}


Espero que te sirvan de ayuda, si no entiendes algo, no dudes en preguntarlo ok? Intenta hacerlo mirando estos códigos y si te da errores pues postealo de nuevo 

mmm...
no es necesario llenar todo eso y usar tablas; fijate que con 3 simples ints lo puedes hacer.
mira:

No es muy complicado de entender creo...
Simplemente imprime los multiplos de 'i2' hasta el 10 en cada linea.
El if es para fijarse si 'i' (que es el numero por el cual 'i2' se multiplicará) llegó a 10, para así imprimir el caracter de nueva linea.

En C++

Hombre esta claro q con 2 for le haces las tablas de multiplicar del 0 hasta q t canses, si queire una tabla especifica pues que pase un numero y con un for, pero también puede memorizar las tablas de multiplicar en una matriz mediante punteros y luego visualizarla, todo depende de lo que quiera hacer...no? que si le gusta complicarse la vida..es cosa suya

para este caso lo veo mas facil hacer los 2 for.. depende de lo que el quiera hacer.
igual cualquiera de las dos cosas son válidas

Amigo estas preguntando si es posible usar punteros
para hacer uinas tablas
mmm
pues de k ees posible es posible... pero como escribio Kira ,los punteros se usan para manpular memoria dinamica es decir en tiempo de ejecucion..
con los punteros pudieras hacer las tablas de multiplñicar del 1 hasta el numero ke kieras en tiempo de ejecucion y solo usando la memoria ke nececitas en tiempo real..
no almacennando un espacio ke tal vez no lo llenes..

jujuju! yeah! gracias! a kira y a los demas...=)
se os agradece ;D