拷贝构造函数和const成员函数

实验原因

说明如何使用const描述保护类数据不会意外修改.

编译环境

vc6sp6 + win7x64

工程下载

copyConstruction_constMemberFunction.zip

 

使用非const成员函数,引起的拷贝构造函数报错

  1. class CStudent
  2. {
  3. /// 常量定义
  4. public:
  5. enum {NAME_SIZE_MAX = 64};
  6. /// 构造, 拷贝构造, 析构函数
  7. public:
  8. CStudent();
  9. CStudent(const char* pcName, size_t nId = 1, int iAge = 20);
  10. CStudent(const CStudent& src);
  11. virtual ~CStudent();
  12. /// 成员函数
  13. public:
  14. void clear();
  15. private:
  16. void init(); ///< 类初始化
  17. void uninit(); ///< 类反初始化
  18. void copy(CStudent& src);
  19. /// setter, getter
  20. public:
  21. // m_nId
  22. void setter_m_nId(size_t nIn) {m_nId = nIn;}
  23. size_t getter_m_nId() {return m_nId;}
  24. // m_cName
  25. void setter_m_cName(const char* pcIn)
  26. {
  27. if (NULL == pcIn)
  28. return;
  29. memset(m_cName, '\0', NAME_SIZE_MAX);
  30. strncpy(m_cName, pcIn,
  31. (strlen(pcIn) < (NAME_SIZE_MAX - 1)) ?
  32. strlen(pcIn) : (NAME_SIZE_MAX - 1));
  33. }
  34. const char* getter_m_cName() {return m_cName;}
  35. // m_iAge
  36. void setter_m_iAge(int iIn) {m_iAge = iIn;}
  37. int getter_m_iAge() {return m_iAge;}
  38. /// 成员变量
  39. private:
  40. size_t m_nId; ///< 学号
  41. char m_cName[NAME_SIZE_MAX]; ///< 姓名
  42. int m_iAge; ///< 年龄
  43. };
  1. CStudent::CStudent(const CStudent& src)
  2. {
  3. copy(src);
  4. }
  5. void CStudent::copy(CStudent& src)
  6. {
  7. setter_m_cName(src.getter_m_cName());
  8. setter_m_nId(src.getter_m_nId());
  9. setter_m_iAge(src.getter_m_iAge());
  10. }

拷贝构造函数声明为(const class&), 但是拷贝构造函数调用了非const成员函数, 会报错

error C2664: 'copy' : cannot convert parameter 1 from 'const class CStudent' to 'class CStudent &'

如果要查报错资料资料, 查一下关键字.

error C2664: cannot convert parameter 1 from 'const class ' to 'class &'

需要将拷贝构造函数(直接, 简捷)调用的成员函数全部改成const成员函数,

需要将拷贝构造函数调用的成员函数入参为class& 或 class*全部改成 const class& 或 const class*

  1. class CStudent
  2. {
  3. /// 常量定义
  4. public:
  5. enum {NAME_SIZE_MAX = 64};
  6. /// 构造, 拷贝构造, 析构函数
  7. public:
  8. CStudent();
  9. CStudent(const char* pcName, size_t nId = 1, int iAge = 20);
  10. CStudent(const CStudent& src);
  11. CStudent(const CStudent* psrc);
  12. virtual ~CStudent();
  13. /// 成员函数
  14. public:
  15. void clear();
  16. private:
  17. void init(); ///< 类初始化
  18. void uninit(); ///< 类反初始化
  19. void copy(const CStudent* psrc);
  20. /// setter, getter
  21. public:
  22. // m_nId
  23. void setter_m_nId(size_t nIn) {m_nId = nIn;}
  24. size_t getter_m_nId() const {return m_nId;}
  25. // m_cName
  26. void setter_m_cName(const char* pcIn)
  27. {
  28. if (NULL == pcIn)
  29. return;
  30. memset(m_cName, '\0', NAME_SIZE_MAX);
  31. strncpy(m_cName, pcIn,
  32. (strlen(pcIn) < (NAME_SIZE_MAX - 1)) ?
  33. strlen(pcIn) : (NAME_SIZE_MAX - 1));
  34. }
  35. const char* getter_m_cName() const {return m_cName;}
  36. // m_iAge
  37. void setter_m_iAge(int iIn) {m_iAge = iIn;}
  38. int getter_m_iAge() const {return m_iAge;}
  39. /// 成员变量
  40. private:
  41. size_t m_nId; ///< 学号
  42. char m_cName[NAME_SIZE_MAX]; ///< 姓名
  43. int m_iAge; ///< 年龄
  44. };
  1. CStudent::CStudent(const CStudent& src) ///< 入参改成const class&
  2. {
  3. copy(&src);
  4. }
  5. CStudent::CStudent(const CStudent* psrc)
  6. {
  7. copy(psrc);
  8. }
  9. void CStudent::copy(const CStudent* psrc)
  10. {
  11. setter_m_cName(psrc->getter_m_cName());
  12. setter_m_nId(psrc->getter_m_nId());
  13. setter_m_iAge(psrc->getter_m_iAge());
  14. }

const 成员函数的含义

摘录自 <<C++ const详解>>

http://blog.csdn.net/zhuanshenweiliu/article/details/38223907

3. const成员函数
任何不会修改数据成员(即函数中的变量)的函数都应该声明为const类型。

如果在编写const成员函数时,不慎修改了数据成员,或者调用了其它非const成员函数,编译器将指出错误,这无疑会提高程序的健壮性。

以下程序中,类stack的成员函数GetCount仅用于计数,从逻辑上讲GetCount应当为const函数。编译器将指出GetCount函数中的错误。
class Stack
{
public:
void Push(int elem);
int Pop(void);
int GetCount(void) const; // const成员函数
private:
int m_num;
int m_data[100];
} ;
int Stack::GetCount(void) const
{
++ m_num; //编译错误,企图修改数据成员m_num
Pop(); //编译错误,企图调用非const函数
return m_num;
}
const 成员函数的声明看起来怪怪的:const 关键字只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。
关于Const函数的几点规则:
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.

http://blog.csdn.net/lostspeed/article/details/50291749

上一篇:序列化与反序列化中serialVersionUID的作用(通俗易懂)


下一篇:JS移动客户端--触屏滑动事件 banner图效果