Hola amigos.. que tal.

Tengo una gran duda, la verdad me confunde un poco el hecho de que se pueda inicializar una variable de 3 formas:

int x = 3;
int y {4};
int z(5);
 

Las 3 son válidas, bueno, así como se ve, no está complejo realmente, el problema es cuando usas elementos como un contenedor.. ya que los contenedores aceptan una lista de argumentos encerradas en llave, sin embargo esto me confunde un poco, porque no se cuando está inicializando o cuando está pasando por argumento a un constructor.. o cuando está usando un constructor de conversión.. etc..


Ejemplo:

 
vector<string> vs { "Hola", " Que tal"};     //No hay problema..
vector<string> vs2 { 5, 1 };                     //Houston
 
istream_iterator<string> is;
istream_iterator<string> is2;
 
vector<string> vs3{is, is2};                     //No hay problema.. por que?
 
 

Sospecho que en vs3 no estoy inicializando … pensé que las llaves eran para eso... que esta pasando en esta línea?..


Saludos y gracias.


--------------------------------

Edito:

Estuve viendo los constructores que tiene std::vector y encontre uno que acepta un iterator de inicio y otro de fin... entonces eso es lo que debe estar aceptando, es decir,  vs3 no esta inicializando, solo le estoy pasando los iteradores que están conectados al flujo de entrada ifstream....  En el fondo lo que me habia confundido es el uso de las llaves, tenia entendido que las llaves servian para inicializar en los contenedores, pero ya vi que hace lo mismo que los parentesis, a menos que este poblando al contenedor, ahi seria una inicialización...

Saludos.

El switch-case esta cortado por las definiciones de funciones. Si metes las funciones al final, se acaba el problema:

#include <iostream>
#include <cstdlib>
#include <conio.h>
#include <stdlib.h>
 
using namespace std;
 
void pausa();
 
 struct Nodo{
   int dato;
   Nodo *siguiente;
};
 
 
 
 
//Prototipos de Función
void agregarPila(Nodo *&,int);
void sacarPila(Nodo *&,int &);
void mostrarPila(Nodo *&,int &);
int main(){
    bool bandera=false;
    char tecla;
 
    do{
        system("cls");
        cin.clear();
        cout << "Calculadora" << endl;
        cout << "-----------" << endl << endl;
        cout << "\t1 .- Sumar" << endl;
        cout << "\t2 .- Restar" << endl;;
        cout << "elige una opcion: ";
 
        cin >> tecla;
 
      switch(tecla){
         case '1':
                {
                Nodo *pila = NULL;   //Inicializamos pila
                int dato, aux;
                char rpt;
                aux=5;
                do{ //Pedimos todos los elementos de la pila
                    //cout<<"Digite un numero: ";
                    //cin>>dato;
                    if (aux<=0||aux>5){
                        cout<<"Alcanzo los 5 digitos: ";
                        break;
                    }
                    cout<<"Digite un numero: ";
                    cin>>dato;
 
                    if(dato==0){
                        if((aux==5)||(aux==4)||(aux==2)||(aux==1)||(aux==0)){
                            //cout<<aux-1;
                            agregarPila(pila,dato);
                        } else {
                            cout<<"\nNO ES UN VALOR ACEPTADO: ";
                            break;
                        }
 
                        aux=aux-1;
                        cout<<aux;
                    }
 
 
                if(dato==1){
                    if(aux==3){
                        //cout<<aux-1;
                        agregarPila(pila,dato);
                    } else {
                        cout<<"\nNO ES UN VALOR ACEPTADO: ";
                        break;
                    }
                    aux=aux-1;
                    cout<<aux;
                }
 
                if (aux<=0 || aux>5){
                    cout<<"\n\nAlcanzo los 5 digitos: ";
                    break;
                }          
 
                cout<<"\nDesea agregar otro numero a pila(s/n): ";
                cin>>rpt;
 
            } while((rpt == 's')||(rpt=='S'));
 
      //if (aux<=0||aux>5)
      //{
         //   cout<<"Alcanzo los 5 digitos: ";
            //break;
        //}
 
 
   //cout<<"\nIMPRESION #2: \n";
   //cout<<"\nIMPRESION #2: \n";
            cout<<"Mostrando los elementos de la pila en la columna ENTRADA: ";
   //while(pila != NULL){
   //   sacarPila(pila,dato);
 
   //   if(pila != NULL){
   //      cout<<dato<<" , ";
   //   }
   //   else{
   //      cout<<dato<<".";
   //   }
   //}
 
 
   //cout<<"\n\n\nIMPRESION #2: \n";
            cout<<"\n\tESTADO\tENTRADA\tRESULTADO\n";
 
            int a=0;
            int b=0;
 
 
            while(pila != NULL){
                sacarPila(pila,dato);
 
                if(pila != NULL){
                    cout<<"\t q"<<a<<"\t "<<dato<<"\t q"<<b<<"\n";
                    if((a==0)&&(b==0)){
                        a=0+dato;
                        b=0+dato;
                    } else {
                        a=1;
                        b=1;
                    }
                } else{
                    cout<<"\t q"<<a<<"\t "<<dato<<"\t q"<<b<<"\n";
                }
            }
 
 
            getch();
            return 0;
 
        }
 
 
         case '2':
            system("cls");
            cout << "Has elejido Restar.\n";
            pausa();
            break;
 
         default:
            system("cls");
            cout << "Opcion no valida.\a\n";
            pausa();
            break;
      }
    }while(bandera!=true);
 
    return 0;
}
 
void pausa()
{
    cout << "Pulsa una tecla para continuar...";
    getwchar();
    getwchar();
}
 
void agregarPila(Nodo *&pila,int n){
   Nodo *nuevo_nodo = new Nodo();
   nuevo_nodo->dato = n;
   nuevo_nodo->siguiente = pila;
   pila = nuevo_nodo;
 
   cout<<"\n\tElemento "<<n<<" agregado a PILA correctamente"<<"\n";
}
void sacarPila(Nodo *&pila,int &n){
   Nodo *aux = pila;
   n = aux->dato;
   pila = aux->siguiente;
   delete aux;
}
void mostrarPila(Nodo *&pila,int &n){
   Nodo *aux = pila;
   n = aux->dato;
   pila = aux->siguiente;
   delete aux;
}
 

Asi es, lo he notado, no pude declarar las funciones no miembro como const... pero no me haré problemas al menos por ahora y las declarare como funciones miembro...

saludos.

Muy bien, buenísimas explicaciones, me quedó claro, entonces es una regla del compilador todo esto, ahora le hallo sentido...

@Loretz si tienes tu libro a mano, veras que en la pagina 78 se usa la version const, pero en la pagina 77 solo están definidos begin() y end() de forma no constante... entonces supongo que la reseña esta imcompleta... verdad?

Entiendo!.. gracias por contestar!

He estado observando en el libro que estoy estudiando otras cosas que no me parecen (yo a pesar de ser un poco novato) muy comprensibles...

Luego me puse a indagar sobre las Erratas del libro y me tope con esto:
http://www.stroustrup.com/4th_printing3.html

Como verán en la pagina 74 (que es justo el punto que quería discutir en este post), en realidad el problema es por una cuestion de impresion, es decir, lo que esta escrito en la pagina 74 fue sin intencion (por algun minuto se me paso que podia ser asi y que se habia cometido un error)..


Dice:
pg 74, top: s/new double[sz]/new double[a.sz]/

...por lo que new double[a.sz] tiene mucho mas sentido que lo anterior...

Saludos!

Hola amigos..

En el siguiente código, si yo quito la palabra const (línea 52) derivada de un template tipo C, el programa corre....


Link -> https://onlinegdb.com/SyW1F9kWS
Hagan clic en Fork para probar el código.

Estuve buscando por què pasa esto, segun el compilador no pudo realizar una conversion de un tipo que no es const a uno que es const...  entiendo que quitando la palabra const se acaba el problema, pero por que?.. y si no deseo retirar la palabra const donde mas debería agregarla para que pueda compilar?... (Pasa que el libro que estudio aparece con const, ero no veo diferencia realmente con lo que tengo).

Gracias.

---

Bueno, según un usuario de discord, me dijo que las funciones begin() y end() deben ser const también, y efectivamente colocándolas asi compiló correctamente.

Pero es curioso porque en el libro que estudio, dichas funciones no son const..

Ahora mismo estoy investigando por que´.

---

Si yo coloco las funciones begin() y end() como funciones no miembro, es decir, fuera de la clase o estructura, el compilador no las detecta...

Lnik -> https://onlinegdb.com/SJgL5ayZH


Debe forzosamente ser funciones miembro?

EI: NO HAGAS DOBLE POST NUEVAMENTE, SERA BORRADO.

Entonces en tal caso no sería mejor inicializar tam y luego iArray con tam? o colocar primero en el campo privado del struct a tam y en la siguiente línea al array...

ok, el compilador determina esto siempre y cuando se este evaluando la línea actual o no?

Edit: Ya me quedo claro gracias.!

Hola amigos. que tal.

Tengo el siguiente caso:

 
#include <iostream>
#include <initializer_list>
 
struct x {
private:
     int * iArray = nullptr;
     int tam;       //Sin inicializar
 
public:
     x(std::initializer_list<int> lst) : iArray{new int[lst.size()}, tam{lst.size()}{
          std::copy(lst.begin(), lst.end(), iArray);
     }
 
     //Constructor de copia
     x(const x & otherX);
 
};
 
//Definición de constructor de copia (notar aquí que al momento de hacer
//la primera inicialización tam no ha recibido valor.
x::x(const x & otherX) : iArray{new int[tam]}, tam{otherX.tam}{
     for (int y = 0; y < tam; ++y){
          iArray[y] = otherX.iArray[y];
     }
}
 
int main (){
     x x0 {2, 4, 6};
     x x1 = x0;   //copia correcta...
 
     //prueba directa de asignacion de una variable no definida a un array dinamico:
 
     int x;
     int * arr = new int[x];     //error, x no está definida.
}
 

Como se puede observar, en la linea 22 se está inicializando el array dinamico con un tamaño de tam antes que inicializar al mismo tam, o sea, se esta inicializando con un valor desconocido...  sin embargo, esta funcionando bien, ahora bien, en la linea 35, se esta intentando crear un array dinamico con un tamaño x, pero no sirvio.... acaso la inicialización funciona distinto a la asignacion?

Gracias, saludos.

Vim