zoukankan      html  css  js  c++  java
  • const关键字总结

    const关键字

    被const修饰的变量是不能改变的
    const修饰变量时,必须在声明变量的同时给出初始化(类中的const成员变量不一样)

    顶层const与底层const

    顶层const

    定义为变量本身是一个常量,因此对一切的内置类型常量而言,所有的const都是顶层const
    对指针来说,常量指针是顶层const,对于引用则没有顶层const的概念。

    底层const

    只在指针和引用上有效,其定义是该指针指向或该引用绑定的对象是常量。
    因此:顶层const和底层const,引用只有底层const。

    int main()
    {
    	int a = 10;
    	int aa = 100;
    
    	const int *b = &a;	//底层const指针
    	*b = 20;	//错误,底层const指针不可以修改指向的值
    	b = &aa;	//正确,底层const指针可以指针的指向
    
    	int * const c = &a;		//顶层const指针
    	*c = 20;	//正确,顶层const指针可以修改指针指向的值
    	c = &b;	//错误,顶层const指针不能修改指针的指向
    
    	b = c;	//底层const指针可以指向顶层const指针(顶层const可以赋值给底层const)
    	c = b;	//底层const指针不可以赋值给顶层const指针
    
    	const int& e = a;	//引用的底层const
    	e = 1000;	//错误,引用的底层const不能修改值
    
    	const int* const f = &aa;	//同时被顶层和底层const封锁的指针既不能修改其指向,也不能修改其指向的内容
    
    	return 0;
    }
    

    const与函数

    成员函数后使用const

    就不能对此方法生命周期外的变量值修改,可以保护成员变量不被方法修改

    class Example
    {
    public:
        int getData() const
        {
            m_data = 100;    //错误,成员函数后使用const,不能对该方法生命周期外的变量值修改,保护了成员变量
            return m_data;
        }
    private:
        int m_data;
    };
    

    函数成员前加const

    保证在外部调用该方法后,返回值不会被篡改

    class Example
    {
    public:
    	const int* getData() const
    	{
    		return &m_data;
    	}
    private:
    	int m_data;
    };
    
    int main(int argc, char* argv[])
    {
    	Example e;
    	*e.getData()=100;	//错误,函数前加了是const,返回值不能被篡改
    	return 0;
    }
    

    const与mutable

    mutable 是为了突破 const 的限制而设置的。可以用来修饰一个类的成员变量。被 mutable 修饰的变量,将永远处于可变的状态,即使是 const 函数中也可以改变这个变量的值。

    class Example
    {
    public:
    	int getData() const
    	{
    		m_isdone = true;	//正确,被mutable修饰的类的成员变量,即使在被const修饰的成员函数中也能被修改
    		return m_data;
    	}
    private:
    	int m_data;
    	mutable bool m_isdone;
    };
    

    const与类和对象

    类的const对象只能调用类的const成员函数,类的非const对象可以调用const成员函数和非const成员函数

    class Example
    {
    public:
    	int getData() const
    	{
    		return m_data;
    	}
    private:
    	int m_data;
    };
    
    int main(int argc, char* argv[])
    {
    	const Example e1;
    	e1.getData();
    
    	Example e2;	//正确,类的非const成员可以调用const成员函数和非const成员函数
    	e2.getData();
    
    	return 0;
    }
    

    不能在类声明中初始化const数据成员,因为类的对象未被创建时,编译器不知道const成员的值是什么。const数据成员的初始化只能在类构造函数的初始化表中进行!

    class Example
    {
    public:
    	Example(int data):m_data(data){}	//const成员的初始化只能在类构造函数的初始化表中进行
    private:
    	const int m_data;	//const成员
    };
    
    int main(int argc, char* argv[])
    {
    	Example e1(10);
    	return 0;
    }
    

    想要在类中建立恒定的常量,应该用类中的枚举常量来实现。

    class Example
    {
    public:
    	Example():m_data(DATA1){}
    private:
    	enum {DATA1=100,DATA2=200};	//枚举常量成员
    	int m_data;
    };
    
    int main(int argc, char* argv[])
    {
    	Example e1();
    	
    	return 0;
    }
    

    枚举常量不会占用对象的存储空间,它们在编译时被全部求值。枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数。

  • 相关阅读:
    learnyou 相关网站
    hdu 3038 How Many Answers Are Wrong
    hdu 3047 Zjnu Stadium 并查集高级应用
    poj 1703 Find them, Catch them
    poj 1182 食物链 (带关系的并查集)
    hdu 1233 还是畅通工程
    hdu 1325 Is It A Tree?
    hdu 1856 More is better
    hdu 1272 小希的迷宫
    POJ – 2524 Ubiquitous Religions
  • 原文地址:https://www.cnblogs.com/WindSun/p/11434431.html
Copyright © 2011-2022 走看看