problemas con de stl

22/04/2004 - 12:50 por Sergio | Informe spam

Quiero pasar datos de una lista a otra, cuando hacen doble click sobre
una listctrl. El problema es que en la linea que hago:
lst->SetItemText(i,1,n.puesto);
el valor de n.puesto ¡¡desaparece!!

Os pongo el código para que me digais si hago algo raro.
Podria pensar que no recoge bien el valor, pero he observado el valor de
las variables con puntos de interrupción, y despues de poner el
nombre(lo único que hace bien), los valores se pierden, y que yo sepa,
no tiene sentido.

list<jugador>::iterator act;
CString str;
jugador n;
char aux[10];
list <int>::size_type i;

CListCtrl *lst = (CListCtrl *)GetDlgItem(IDC_DESCONVOCADOS);
if (lst) {
POSITION pos = lst->GetFirstSelectedItemPosition();
if (pos) {
int index = lst->GetNextSelectedItem(pos);
DWORD itemdata;
itemdata = lst->GetItemData(index);
for (act = m_jugadores.begin();act != m_jugadores.end();act++) {
if (itemdata == act->id) {
n = (*act);
m_convocados->push_back((*act));
lst->DeleteItem(index);
lst = (CListCtrl *)GetDlgItem(IDC_CONVOCADOS);
i = m_convocados->size();
lst->InsertItem(i,n.nombre);
lst->SetItemText(i,1,n.puesto);
_itoa(n.num,aux,10);
lst->SetItemText(i,2,aux);
m_jugadores.erase(act);
break;
}
}
}
}

tb he probado esto por si acaso, pero tampoco:

list<jugador>::iterator act;
CString str;
jugador n;
char aux[10];
list <int>::size_type i;
CListCtrl *lst = (CListCtrl *)GetDlgItem(IDC_DESCONVOCADOS);
if (lst) {
POSITION pos = lst->GetFirstSelectedItemPosition();
if (pos) {
int index = lst->GetNextSelectedItem(pos);
DWORD itemdata;
itemdata = lst->GetItemData(index);
for (act = m_jugadores.begin();act != m_jugadores.end();act++) {
if (itemdata == act->id) {
m_convocados->push_back((*act));
lst->DeleteItem(index);
lst = (CListCtrl*)GetDlgItem(IDC_CONVOCADOS);
i = m_convocados->size();
lst->InsertItem(i,(*act).nombre);
lst->SetItemText(i,1,(*act).puesto);
_itoa((*act).num,aux,10);
lst->SetItemText(i,2,aux);
m_jugadores.erase(act);
break;
}
}
}
}

gracias por adelantado.

Siga el debate

4 respuestas

Tengo una respuesta

Preguntas similare

Mostrar todos los temas similares

Leer las respuestas

#1 Sergio

22/04/2004 - 13:02 | Informe spam

Me he dado cuenta que declaro i de una forma erronea, en realidad
deberia ser así:
list <jugador>::size_type i;
pero aún y todo no hace lo que espero.

Responder a este mensaje

#2 Sergio

22/04/2004 - 13:14 | Informe spam

Ya he encontrado el fallo, o la solución:
el caso es que después de hacer i = m_convocados->size(); tengo que
hacer i--;

Responder a este mensaje

#3 Cholo Lennon

22/04/2004 - 17:41 | Informe spam

Simple consejo para iterar con STL:

Es más eficiente, dentro de un ciclo incrementar antes y no después. La
linea siguiente:

for (act = m_jugadores.begin();act != m_jugadores.end();act++)

Cámbiala por :

for (act = m_jugadores.begin();act != m_jugadores.end(); ++ac)

Esto es debido a que el operador de sufijo necesita crear una variable
temporal para hacer el incremento, no así operador de prefijo. Mira el
siguiente fragmento tomado de un iterador:

const_iterator& operator++()
{
_Ptr = _Acc::_Next(_Ptr);
return (*this);
}

const_iterator operator++(int)
{
const_iterator _Tmp = *this;
++*this;
return (_Tmp);
}

Como puedes observar el operador de sufijo no sólo crea una variable
temporal, si no que utiliza al operador de prefijo para hacer lo suyo.
Quizás no sea tu caso (de que necesites velocidad), pero en grandes
iteraciones es crítico el asunto.
Entonces, dentro de lo posible, incrementa siempre antes y no después.

Saludos
Cholo Lennon
Salta, ARG

Responder a este mensaje

#4 Sergio

22/04/2004 - 17:45 | Informe spam

Cholo Lennon escribió:

Simple consejo para iterar con STL:

Es más eficiente, dentro de un ciclo incrementar antes y no después. La
linea siguiente:

for (act = m_jugadores.begin();act != m_jugadores.end();act++)

Cámbiala por :

for (act = m_jugadores.begin();act != m_jugadores.end(); ++ac)

Esto es debido a que el operador de sufijo necesita crear una variable
temporal para hacer el incremento, no así operador de prefijo. Mira el
siguiente fragmento tomado de un iterador:

const_iterator& operator++()
{
_Ptr = _Acc::_Next(_Ptr);
return (*this);
}

const_iterator operator++(int)
{
const_iterator _Tmp = *this;
++*this;
return (_Tmp);
}

Como puedes observar el operador de sufijo no sólo crea una variable
temporal, si no que utiliza al operador de prefijo para hacer lo suyo.
Quizás no sea tu caso (de que necesites velocidad), pero en grandes
iteraciones es crítico el asunto.
Entonces, dentro de lo posible, incrementa siempre antes y no después.

Gracias por la corrección. La verdad es que hace muy poco que uso STL,
de hecho las lístas son lo único que conozco, y no me habia parado a
pensar en términos de eficiencia. Nuevamente, gracias.

Siga el debate Respuesta

Responder a este mensaje

Ads by Google

Hacer una pregunta

Tengo una respuesta

Busqueda sugerida