Mensajes

Es que no habia llegado a ese punto porque me quede pensando en la función de la transpuesta. Pero luego de eso implemento correctamente el código.

Código (cpp) [Seleccionar] Expandir

delete[] matrizPrincipal; // liberando memoria de la matriz
es así verdad como se hace cierto??

Primero debes liberar la memoria de cada fila y a continuación la memoria del bloque principal:

Código (cpp) [Seleccionar] Expandir

for (int i = 0; i != tamanyo; ++i)
   delete[] matrizPrincipal[i];
delete[] matrizPrincipal;

Un saludo

Tengo un error a la hora de intentar acceder a un elemento de una lista en c++

Hay dos errores en el programa.

El primero es el uso de typedef, en C++ no es necesario (con usar la etiqueta basta) y su forma no es la correcta, en C (donde si es necesario) seria así:

Código (c) [Seleccionar] Expandir

typedef struct nodo {
   int num;
   struct nodo* sig;
} tNodo;

El segundo y mas importante: el argumento de la función "insertar" se pasa por valor y el parámetro "cab" es una variable local (única) a la función, puedes hacer lo que quieras con ella sin afectar el valor de la variable "cabecera" de la función main.

Para solucionarlo solo debes cambiar la declaración y definición de la funcion "insertar" para indicar el uso de una referencia:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using namespace::std;

struct tNodo {
   int num;
   tNodo* sig;
} ;

void insertar(tNodo*& cab, int dato);

int main()
{
   tNodo* cabecera = 0; // En C++ lo politicamente correcto es 0
   insertar(cabecera, 2);
   cout << cabecera->num << endl;
   delete cabecera;
   
   return 0;
}

void insertar(tNodo*& cab, int dato)
{
   if (cab == 0){
      cab = new tNodo;
      cab->num = dato;
   }
}

Un saludo

Si apenas empiezas lo primero que debes hacer es leer el tema |Lo que no hay que hacer en C/C++. Nivel basico|.

El problema que mencionas se debe a que en C y C++ el separador no es la coma, es el punto.

Un saludo

Código (c) [Seleccionar] Expandir


#define MAX 30

int main(void){
char nombre_completo[93], *ptrNC = nombre_completo,
primer_nombre[MAX+1], *ptrPN = primer_nombre,
segundo_nombre[MAX+1], *ptrSN = segundo_nombre,
apellido[MAX+1], *ptrAP = apellido;
int longitud;

printf("\n\n Ingrese primer nombre.....: ");
fgets(ptrPN, MAX, stdin);

/* ... */
}

No es necesario declarar los arrays con un carácter adicional ya que al llamar a fgets su segundo argumento indica el numero máximo de caracteres a almacenar y ello incluye el '\0'. En otras palabras los puedes declarar con MAX caracteres sin ningún problema.

Un saludo

[EXTRAER DESDE LA IZQUIERDA]

Estoy haciendo un programa en C y una opción es extraer caracteres comenzando desde la izquierda [...]

EXTRAER DESDE LA IZQUIERDA

Código (c) [Seleccionar] Expandir


printf("Cuantos caracteres quieres extraer? ");
scanf("%d", &extraerIzq);

for (i=0; i<longitud && i<extraerIzq; i++){
   printf("\nSe ha extraido: %c", cadena[i]);
}

Para imprimir los primeros caracteres de una cadena no es necesario un bucle, puedes utilizar printf con el especificador "%.*s" donde ".*" indica que el siguiente argumento de la función sera el máximo de caracteres a imprimir. Siguiendo tu ejemplo:

Código (c) [Seleccionar] Expandir

printf("Cuantos caracteres quieres extraer? ");
fflush(stdout);
if (scanf("%d", &extraerIzq) == 1 && extraerIzq > 0)
   printf("%.*s\n", extraerIzq, cadena);

Un saludo

Lo primero a cambiar es el nombre del encabezado por el políticamente correcto: <cstdio>. También deberías eliminar las macros en favor del tipo bool: true si se debe ordenar de forma ascendente y false en caso contrario. Y el prototipo y definición de la función "MostrarLista" no coinciden.

Otro detalle que no gusta del programa es, salvo el uso del operador new (es un operador que no requiere paréntesis) y la omisión de struct en las declaraciones, el programa no tiene nada de C++.

En cuanto a la función "Insertar" tiene varios errores, para empezar si el nodo a insertar debe colocarse antes del primero no hay forma de afectar a la variable "lista" de la función main ya que esta se pasa por valor.

La función con los cambios:

Código (cpp) [Seleccionar] Expandir

void Insertar(nodo*& apuntador, int v);

// ...

void Insertar(nodo*& lista, int v)
{
   nodo *nuevo = new nodo;
   nuevo->datoNodo.valor = v;
   
   if (!lista || lista->datoNodo.valor > v){
      nuevo->siguiente = lista;
      nuevo->anterior = 0;
      if (lista)
         lista->anterior = nuevo;
      lista = nuevo;
   }else {
      nodo *p = lista;
     
      while (p->siguiente && p->siguiente->datoNodo.valor <= v)
         p = p->siguiente;
     
      nuevo->siguiente = p->siguiente;
      nuevo->anterior = p;
      p->siguiente = nuevo;
      if (nuevo->siguiente)
         nuevo->siguiente->anterior = nuevo;
   }
}

Un saludo

Código (cpp) [Seleccionar] Expandir

double (*p_array)[M];
double *p_double;

Que significa particularmente el (*p_array)[M], hay que indireccionar por separado las columnas y las filas?

Por partes.

Tienes un array de arrays de doubles (el array mt) y la intención es practicar con los punteros y la aritmética con estos. Para procesar un array de tipo "T [N]" se debe utilizar un puntero de tipo "T *". En este caso:
1) El array es mt y el tipo de sus elementos es "double [M]"
2) El puntero para procesar cada elemento debe ser de tipo "double (*)[M]", se utilizan paréntesis porque de no hacerlo (utilizando "double *[M]") la declaración se tomaría como la de un array de M elementos de tipo "double *", en otras palabras no seria un puntero a array sino un array de punteros (no es lo mismo y no es igual).

Con el puntero "p_array" procesamos cada uno de los elementos del array mt (mt[ 0 ], mt[ 1 ], etc.), como este es un array de arrays cada elemento también es un array y ahí utilizamos el puntero "p_double" para procesar los elementos:

Código (cpp) [Seleccionar] Expandir

// Por cada elemento del array mt (mt[0], mt[1], ...)
for (p_array = mt; p_array < mt + N; p_array++){
   // Por cada elemento del array mt[i] (mt[i][0], mt[i][1], ...)
   for (p_double = *p_array; p_double < *p_array + M; p_double++){
      *(p_double) = 2.00;
   }
}

Que significaria entonces si se hace esto:

Código (cpp) [Seleccionar] Expandir

**(p_double) = 2.00;
*(*(p_double) = 2.00;

No es valido ya que el tipo de "p_double" es "double *", al aplicar el operador de indirección con "*(p_double)" (los paréntesis no son necesarios en este caso) ya no tratas con el puntero sino con el objeto apuntado y no puedes hacer, siguiendo el ejemplo, "*(2.00)".

Un saludo

[Segmentation Fault]

Al momento de escanear el *char mes, me sale un error de Segmentation Fault, y es que eso ocurre con el scanf de esa cadena, no se porque carajos ocurre eso

El problema principal no se debe a scanf sino a las direcciones que le pasas a esta. Cuando declaras una variable local:

Código (c) [Seleccionar] Expandir

struct dato nuevoDato;
Esta inicia con un valor no definido o "basura". Si se trata de estructuras esto aplica a sus campos y el programa reventara tan pronto trates de utilizar uno de los punteros.

Para solucionarlo debes primero reservar dos bloques de memoria y almacenar la dirección de estos en los campos de la variable "nuevoDato":

Código (c) [Seleccionar] Expandir

nuevoDato.mes = malloc(1024);
nuevoDato.r = malloc(sizeof *nuevoDato.r);

También debes eliminar la variable "t" ya que no la utilizas en el programa. El programa con los cambios y algunos mas:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

struct fecha
{
   int d, m, a;
   float x;
};

struct dato
{
   char *mes;
   struct fecha* r;
};

int main(void)
{
   struct dato nuevoDato;
   
   nuevoDato.mes = malloc(1024);
   nuevoDato.r = malloc(sizeof *nuevoDato.r);
   
   printf("++++++****FECHAS****++++++\n\n");
   printf("Digite La fecha:  \n");
   printf("Dia:  ");
   scanf("%d", &nuevoDato.r->d);

   printf("Mes Letras:  ");
   scanf("%s", nuevoDato.mes);

   printf("Mes numero:  ");
   scanf("%d", &nuevoDato.r->m);

   printf("año:  ");
   scanf("%d", &nuevoDato.r->a);

   printf("Numero coma flotante:  ");
   scanf("%f", &nuevoDato.r->x);

   printf("El dia anotado es:  %d\n", nuevoDato.r->d);
   printf("El mes letras anotado es:  %s\n", nuevoDato.mes);
   printf("El mes numero anotado es:  %d\n", nuevoDato.r->m);
   printf("El año anotado es:  %d\n", nuevoDato.r->a);
   printf("El numero coma flotante anotado es:  %.2f\n", nuevoDato.r->x);
   
   return 0;
}

Un saludo

Código [Seleccionar] Expandir

while ((ch = getchar()) != EOF && ch != '\n');
este código yo lo escribiría así:

Código [Seleccionar] Expandir

while(ch != EOF && != '\n') ch = getchar();
supongo que son equivalentes

No lo son. La forma que propones no es valida ya que "!=" es un operador binario (requiere dos operandos). Un caso similar que de vez en cuando aparece en los foros es:

Código (c) [Seleccionar] Expandir

while (min <= x <= max) ...
Esa es la forma usual en matemáticas pero en C y C++ es un error lógico, aun cuando sea redundante se deben indicar los dos operandos requeridos:

Código (c) [Seleccionar] Expandir

while (min <= x && x <= max) ...

Un saludo

ya solo le faltaria otro argumento para indicarle el tipo de dato, pero como se le puede pasar por argumento un tipo de dato y que este sea int?

No pasas el tipo, pasas un valor entero que indique el tipo. Por ejemplo:

Código (c) [Seleccionar] Expandir

enum tipo {INT, DOUBLE, CHAR};

/* ... */

void leer_valor(char const *msj, int tipo, void *p)
{
   int ch;
   
   printf("%s", msj);
   fflush(stdout);
   
   switch (tipo){
   case INT:
      scanf("%d", (int *) p);
      break;
   case DOUBLE:
      scanf("%lf", (double *) p);
      break;
   case CHAR:
      scanf("%c", (char *) p);
      break;
   }
   
   while ((ch = getchar()) != EOF && ch != '\n')
      ;
}

Para utilizar la función basta con indicar que leer y pasar la dirección del objeto:

Código (c) [Seleccionar] Expandir

int main(void)
{
   int num;
   char ch;
   
   leer_valor("Introduce un entero: ", INT, &num);
   printf("El numero es %d\n", num);
   
   leer_valor("Introduce un caracter: ", CHAR, &ch);
   printf("El caracter es %c\n", ch);
   
   return EXIT_SUCCESS;
}
Falta agregar la validación en el caso de que la función scanf falle.

Lo que me pregunto es por el fflush(stdout), no seria necesario realizar uno para el scanf?? es decir, fflush(stdin) para limpiar el buffer de entrada del teclado?

fflush(stdout) es necesario para asegurarnos de que el texto se envié a la salida estándar, fflush(stdin) no se recomienda (se explica en el tema |Lo que no hay que hacer en C/C++. Nivel basico|), en su lugar se puede eliminar el resto de la linea con un bucle.

Un saludo