[SOLUCIONADO] Referencia a función con cláusula const

[dehm]

Hola:

Tengo la sensación de que este es uno de esos conceptos que tendría que tener más claro pero se ve que no termino de entender algo, y como además es algo básico que se usa de continuo, pues me gustaría entenderlo de una vez.

El caso es que creo una función para leer un miembro privado de una clase, así:

Código C++:

tipo& LeeDato() const
{
    return dato;
}
 

Pero el compilador me arroja este error:
error: invalid initialization of reference of type 'tipo&' from expression of type 'const tipo' return dato;
^

Yo entiendo que si retorno una referencia es para poder tener acceso a ella, y que puede haber un sinsentido si por un lado quiero acceder directamente a un miembro y por otro lado no quiero modificarlo, pero no entiendo el por qué de la prohibición.

O es que tal vez no entienda el sentido de una función que retorna una referencia.

Como siempre, gracias!

[xKuZz]

El problema que te da el compilador reside en que no tiene sentido devolver una referencia en un método declarado const. Puesto que el const de la derecha significa que el uso de dicho método no modifica la clase y es obvio que si lo hace.

Si la semántica implica que no se pueda modificar entonces añadele const al tipo devuelto.

Código C++:

const tipo& leerDato() const {
  return dato;
}
 

Si la semántica implica que se puede modificar quítale el const de la derecha al método.

[dehm]

Iniciado por xKuZz

El problema que te da el compilador reside en que no tiene sentido devolver una referencia en un método declarado const. Puesto que el const de la derecha significa que el uso de dicho método no modifica la clase y es obvio que si lo hace.

Si la semántica implica que no se pueda modificar entonces añadele const al tipo devuelto.

Código C++:

const tipo& leerDato() const {
  return dato;
}
 

Si la semántica implica que se puede modificar quítale el const de la derecha al método.

Gracias xKuZz, por la respuesta. Hice algunas pruebas pero no consigo entender esto del const al final.

Reduciendo la pregunta un poco en plan "hoygan", ¿qué hace realmente el const al final?

[eferion]

Iniciado por dehm

Gracias xKuZz, por la respuesta. Hice algunas pruebas pero no consigo entender esto del const al final.

Reduciendo la pregunta un poco en plan "hoygan", ¿qué hace realmente el const al final?

Ese último const indica que la función no va a modificar el estado del objeto.

Dicho con otras palabras: Si etiquetas una función miembro como const entonces esa función no podrá modificar ninguna variable miembro así como tapoco podrá llamar a funciones no const de la clase.

La excepciones son las siguientes:

• Variables estáticas: no afectan al estado del objeto, luego podrán modificarse desde cualquier función, sea const, no const o estática.
• Funciones estáticas: Dado que lo estático no afecta al estado del objeto (son elementos compartidos por todos los objetos de ese tipo), no pueden ser etiquetadas como const. Además estas funciones podrán ser llamadas desde funciones miembro const.
• variables mutable: mutable es una palabra reservada que indica que la variable en cuestión no se ve afectada por los modificadores "const". Tiene otras connotaciones pero no vienen al caso.

Un pequeño ejemplo:

Código C++:

struct POO
{
  int var;
  mutable int mutVar;
  static int staticVar;
 
  void do()
  {
     test(); // ok
     testConst(); // ok
  }
 
  void doConst() const
  {
    test(); // error. doConst es const y no puede llamar a funciones no-const
    testConst();
  }
 
  void test()
  {
    var = 5; // ok
    mutVar = 5; // ok
    staticVar = 5; // ok
    staticFunc(); // ok
  }
 
  void testConst() const
  {
    var = 5; // error. testConst es const y no puede modificar el estado del objeto
    mutVar = 5; // ok
    staticVar = 5; // ok. Los miembros estáticos no afectan al estado del objeto
    staticFunc(); // ok
  }
 
  static void staticConstFunc() const; // Error. Las funciones estáticas no pueden ser const
 
  static void staticFunc()
  {}
};
 
int POO::staticVar = 0;
 

Un saludo.

[dehm]

Gracias eferion. Perfectamente claro ahora.
Cuando lo estudié, en la web de cconclase, ya decían que la cláusula const tenía su mayor sentido y utilidad cuando hablábamos de funciones miembro, pero no le pillaba el punto.

Marco como solucionado

[dehm]

Bueno, aunque ya lo he marcado como solucionado, pregunto si entonces esta es la mejor forma de establecer una función miembro que sólo va a ser de consulta.

Se trataría de una clase que genera una lista y que será sumada desde fuera.

Código C++:

#include <iostream>
#include <list>
using namespace std;
 
class lista
{
private:
    list<int> m_lista;
 
public:
    lista(){}
    void hazLista(int tam)
    {
        for (int i=0;i<tam;i++)
        {
            m_lista.push_back(i);
        }
    }
    void mostrar()
    {
        for (auto it = m_lista.begin();it!=m_lista.end();++it)
        {
            cout<<(*it)<<endl;
        }
    }
    const list<int>&LeeLista() const
    {
        return m_lista;
    }
 
};
 
int sumarLista (const list<int>& l)
{
    int suma=0;
    for (auto it = l.begin();it!=l.end();++it)
    {
        suma+=(*it);
    }
    return suma;
}
 
int main()
{
 
    lista l;
    l.hazLista(3);
    l.mostrar();
 
    int resultado = sumarLista(l.LeeLista());
    cout<<"Resultado: "<<resultado<<endl;
    return 0;
}
 

[eferion]

Desde mi punto de vista sí, sería la forma correcta. Yo entiendo que la opción por defecto para todas las funciones miembro debería ser const... y solo aquellas en las que la compilación falle (porque modifican realmente el estado del objeto) deberían ver eliminado dicho atributo.

Por otro lado, si me aceptas una crítica constructiva:

tu versión actual de hazLista añade elementos a la lista en vez de inicializarla. Si la idea es que hazLista resetee la lista podrías dejar la función tal que:

Código C++:

void hazLista(int tam)
{
    m_lista = list<int>(tam);
    std::iota(m_lista.begin(), m_lista.end(), 0);
}
 

la función mostrar tiene demasiado código. El for se puede optimizar bastante y, además, siguiendo lo que he dicho antes, debería ser const:

Código C++:

void mostrar() const
{
    for (auto elem : m_lista)
        cout<<elem<<endl;
}
 

La función sumar_lista no se libra de la crítica tampoco jejejeje. La STL tiene funciones muy útiles para no tener que reescribir una y otra vez los mismos algoritmos:

Código C++:

int sumarLista (const list<int>& l)
{
    return std::accumulate(l.begin(), l.end(), 0);
}
 

Un saludo.

[dehm]

Vale, ahora si que sí.

Aunque la clase es sólo un ejemplo esquemático de lo que quiero hacer, ninguna de las observaciones sobre cómo iterar y o usar funciones de acumulación caen en saco roto!