Mensajes

Hola, muy buenas. Estoy haciendo una clase 'Vector' en C++ (tamaño dinámico, pero se asigna una sola vez). El caso es que uno de los constructores acepta una initializer_list, donde puedes poner todos los componentes del vector. Este es el código:

Código (c++) [Seleccionar] Expandir

template<typename TipoComponente>
class Vector {
   [...]
   public:
      [...]
      Vector(const std::initializer_list<TipoComponente> &componentes)
         : Vector(componentes.size())
      {
         typename std::initializer_list<TipoComponente>::const_iterator iterador = componentes.begin();
         int i = 0;
         
         while(iterador != componentes.end()) {
            vector[i] = *iterador;
            i++;
            iterador++;
         }
      }
      [...]
};

LA pregunta es: ¿por qué el compilador me obliga a poner la palabra 'typename' antes de la declaración del iterador? Este es el error que sale si no la pongo:

Código [Seleccionar] Expandir

||=== Build: Debug in Reversi (compiler: GNU GCC Compiler (x86_64)) ===|
..\Reversi\reversi\herramientas\vector.hpp||In constructor 'Vector<TipoComponente>::Vector(const std::initializer_list<_Tp>&)':|
..\Reversi\reversi\herramientas\vector.hpp|22|error: need 'typename' before 'std::initializer_list<_Tp>::const_iterator' because 'std::initializer_list<_Tp>' is a dependent scope|
..\Reversi\reversi\herramientas\vector.hpp|22|error: expected ';' before 'iterador'|
..\Reversi\reversi\herramientas\vector.hpp|25|error: 'iterador' was not declared in this scope|
..\Reversi\reversi\herramientas\vector.hpp||In instantiation of 'Vector<TipoComponente>::Vector(const std::initializer_list<_Tp>&) [with TipoComponente = float]':|
C:\Users\Carlos\Desktop\Programacion\Proyectos\Reversi\main.cpp|43|required from here|
..\Reversi\reversi\herramientas\vector.hpp|22|error: dependent-name 'std::initializer_list<_Tp>::const_iterator' is parsed as a non-type, but instantiation yields a type|
..\Reversi\reversi\herramientas\vector.hpp|22|note: say 'typename std::initializer_list<_Tp>::const_iterator' if a type is meant|
||=== Build failed: 4 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|


No me entero muy bien de lo que me queire decir el compilador. Espero que me puedan ayudar. Muchas gracias!

Si, pero new retorna puntero a obtejo, y ahi no se estan declarando punteros

Cuando usas un define básico, lo que hace el compilador, antes de compilar propiamente, preprocesa el código. En el caso de los define, el preprocesador lo que hace es sustituir literalmente lo que hayas puesto como primera palabra con todo lo que le sigue.

Ejemplo:

Código (cpp) [Seleccionar] Expandir

#define UN_DEFINE variable

int main() {
   int UN_DEFINE;
   
   UN_DEFINE = 10;
   
   return 0;
}

Al preprocesar el código, quedaría así:

Código (cpp) [Seleccionar] Expandir

int main() {
   int variable;
   
   variable = 10;
   
   return 0;
}

Esos son los 'define' más básicos, se pueden elaborar más (por ejemplo, con parámetros)

Hola estas declarando mal, trata con esto

Código (cpp) [Seleccionar] Expandir


Persona miPersona = new Persona("Alex");
Persona otraPersona = new Persona("Sergio");


Eso es en Java.

Código (c++) [Seleccionar] Expandir

cout<<Mipersona.GetNombre();

El método es Getnombre, sin mayúscula en la N

Sabiendo que esto era el error,

Código (c) [Seleccionar] Expandir

char prueba[20];
ret = strtol(str, &prueba, 10);
printf("\nProbando: %c%s%c\n",34,prueba,34);

Está todo bien.

______________________________________________

Si quieres más información de strtol, te aconsejo visitar el siguiente link:

http://www.cplusplus.com/reference/cstdlib/strtol/

Lo que decía hace esto:

1º Se salta todos los espacios que haya en la cadena que le pasas.
2º Te lee y convierte los digitos del numero hasta que se encuentre uno que no sea dígito o cuando llegas al final de la cadena.
3º Te devuelve, además del número, la dirección del primer elemento que se ha encontrado que no es dígito.

Código de ejemplo:

Código (c) [Seleccionar] Expandir

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

int main() {
  char numero_str[] = "124lo que sea";
  int numero;
  char *siguiente;
 
  numero = strtol(numero_str, &siguiente, 10);
 
  fprintf(stdout, "El numero convertido: %i\n", numero);
  fprintf(stdout, "Desplazamiento de \"siguiente\" respecto \"numero_str\": %i\n", (int)siguiente - (int)numero_str);
  fprintf(stdout, "Bytes apuntados por \"siguiente\": '%s'", siguiente);
 
  return 0;
}

Salida:

Código [Seleccionar] Expandir

El numero convertido: 124
Desplazamiento de "siguiente" respecto "numero_str": 3
Bytes apuntados por "siguiente": 'lo que sea'

Como ves, strtol te ha convertido bien el número.

Lo que decía es que strtol lee dígitos hasta que se encuentre uno que no lo sea. En nuestro ejemplo ("124lo que sea"), strtol lee carácter a carácter. '1' es dígito, convierte y continúa. '2' es dígito, convierte y continúa. '4' es dígito, convierte y continúa. 'l' no es dígito, por lo que para ahí, y devuelve la dirección (que pertenece al arreglo) del elemento 'l'. Como se puede ver en el segundo fprintf, este elemento es el 3.

Nota un poco más técnica: te puedes fijar en el detalle de que la dirección de "siguiente" menos la del arreglo es 3, lo que quiere decir que "siguiente" apunta a 3 bytes más allá del arreglo, y como el arreglo tiene 14 elementos, eso significa que "siguiente" apunta a un elemento del arreglo. Esto deja claro que no se usa memoria dinámica.

Hola gracias por responder, pero con strtol no estoy modificando la direccion del puntero simplemente llenandolo. poniendo caracteres dentro

No, una de las cosas que hace strtol es guardarte en la dirección que le pasas la dirección del primer elemento después del número.

"los arreglos se puede decir que son punteros disfrazados"

Eso se dice para facilitar la comprensión de sintaxis de los arreglos, pero la realidad es la que dije. Un arreglo NO es lo mismo que un puntero. Lo único similar entre ellos es su sintaxis.

Lo que no puedes hacer es pasarle la dirección de un arreglo. Conceptualmente no puedes porque no puedes modificar la dirección de un arreglo.

Nota por si quieres sumar conocimientos (conocimientos obtenidos experimentalmente con el compilador MinGW y MinGW-w64): físicamente no puedes porque un arreglo no guarda una dirección de memoria. En realidad, un arreglo no se almacena en memoria. Al referirte a un elemento del arreglo, el compilador sabe la dirección virtual del primer elemento del arreglo, y por tanto sabe la del elemento. Cuando intentas acceder a la dirección de un arreglo, la dirección que obtienes es la misma dirección del primer elemento del arreglo. Código que lo demuestra:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int main() {
  char arreglo[64];
 
  fprintf(stdout, "El arreglo apunta a:        %p\n", arreglo);
  fprintf(stdout, "El arreglo tiene direccion: %p\n", &arreglo);
 
  return 0;
}

Resultado en pantalla:

Código [Seleccionar] Expandir

El arreglo apunta a:        000000000023FE10
El arreglo tiene direccion: 000000000023FE10


Espero que se haya entendido

Sii con el gdb (y mucho esfuerzo, por fin me entere del problema. Con C++ hay que tener un cuidado especial, tanto o mas que con C xD (supongo que sera cuestion de muucha practica, como siempre)

Muchas gracias por sus respuestas!!

No entiendo muy bien eso de duplico. A ver, tengo el método Eliminar, que te elimina una rama del árbol. Este no comprueba que el árbol que le pases sea nulo (es una precondición que no será así, por así decirlo). Una vez que tengo ese método, creo otros dos que te eliminan la rama izquierda y la rama derecha, las cuales comprueban si la rama es válida (si esta no es nula). Una vez que tengo dos métodos que te eliminan dos ramas (sé que se podría haber resumido en una, pero me pareció útil para mis propósitos) tener métodos que te eliminen ramas independientes. El caso es que el constructor elimina el árbol formado por la rama izquierda y elimina el formado por la de la derecha:

Destructor:
   Elimina rama izquierda.
   Elimina rama derecha

No entiendo dónde está el conflicto.

________________________________________________________

He probado, desde el main, hacer lo del constructor, lo he eliminado y así si que funciona.

Nuevo main:

Código (cpp) [Seleccionar] Expandir

int main() {
  ArbolBinario<int> arbol;
 
  arbol.SetDato(7, "");
  arbol.ReemplazarRamaIzda(20, "");
  arbol.ReemplazarRamaIzda(5, "0");
  arbol.ReemplazarRamaDcha(7, "00");
  arbol.ReemplazarRamaDcha(4, "0");
  arbol.ReemplazarRamaIzda(1, "01");
  arbol.ReemplazarRamaDcha(2, "01");
  arbol.ReemplazarRamaDcha(8, "");
  arbol.ReemplazarRamaIzda(10, "1");
 
  cout << arbol.ToString();
 
  arbol.EliminarRamaIzda();
  arbol.EliminarRamaDcha();
 
  return 0;
}

Por lo que alguna condición/requisito especial tiene que tener el destructor.

_____________________________________________________________


He probado a poner cout << "Algo" << endl en el destructor y esto sale:

Algo
Algo
Algo
Algo
Algo
Algo
Algo
Algo
Algo

¿Por qué se llama tantas veces?

______________________________________________________________


Soy nuevo en C++ (vengo de C), ¿delete Objeto llama al destructor del objeto?