第一个const

 调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const Time& t，则不能对传递进来的引用对象进行改变，保护了原对象的属性。

 第二个const 类成员函数中const的使用

 如果一个成员函数的不会修改数据成员，那么最好将其声明为const，因为const成员函数中不允许对数据成员进行修改，如果修改，编译器将报错，这大 大提高了程序的健壮性。

OLED显示
 
#include “sys.h”
 #include “delay.h”
 #include “usart.h”
 #include “led.h”
 #include “oled.h”
 
int main(void)
 {
 u8 t=0;
 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组 2
 delay_init(168); //初始化延时函数
 uart_init(115200); //初始化串口波特率为 115200
 LED_Init(); //初始化 LED
 OLED_Init(); //初始化 OLED
 OLED_ShowString(0,0,“ALIENTEK”,24);
 OLED_ShowString(0,24, “0.96’ OLED TEST”,16);
 OLED_ShowString(0,40,“ATOM 2014/5/4”,12);
 OLED_ShowString(0,52,“ASCII:”,12);
 OLED_ShowString(64,52,“CODE:”,12);
 OLED_Refresh_Gram();//更新显示到 OLED 
 t=’ ‘;
 while(1)
 { 
 OLED_ShowChar(36,52,t,12,1);//显示 ASCII 字符
 OLED_ShowNum(94,52,t,3,12); //显示 ASCII 字符的码值
 OLED_Refresh_Gram(); //更新显示到 OLED
 t++;
 if(t>’~’)t=’ ';
 delay_ms(500);
 LED0=!LED0;
 }
 }
 
注：若oled是7脚的，在oled.h中将OLED_MODE 设置为OLED_MODE 0
 若是16脚的，OLED_MODE 设置为OLED_MODE 1

问题：c++：void display( ) const 中的const是什么意思？
 简答：
 意思是除了表明了mutable的成员变量以外
 该类的其他的成员变量在这个函数内一律不能修改。
 
 详细：
 加const表明，该函数只能是只读的，不能修改私有变量的值。加强安全性。
 给隐含的this指针加const，表示这个this指向的东西是const的，也就是说这个函数中无法改动数据成员了。const是一种保证，告诉你这 个成员不会改变对象的状态。
 
 类的成员函数后面加 const，表明这个函数不会对这个类对象的数据成员（准确地说是非静态数据成员）作任何改变。
 
 在设计类的时候，一个原则就是对于不改变数据成员的成员函数都要在后面加 const，而对于改变数据成员的成员函数不能加 const。所以 const 关键字对成员函数的行为作了更加明确的限定：有 const 修饰的成员函数（指 const 放在函数参数表的后面，而不是在函数前面或者参数表内），只能读取数据成员，不能改变数据成员；没有 const 修饰的成员函数，对数据成员则是可读可写的。
 
 除此之外，在类的成员函数后面加 const 还有什么好处呢？那就是常量（即 const）对象可以调用 const 成员函数，而不能调用非const修饰的函数。正如非const类型的数据可以给const类型的变量赋值一样，反之则不成立。
 
 请看下面一个完整的例子，然后我再作一些说明。
 
  
 
 

  CODE:
 
 
 

  [Copy to clipboard]
 
 
 

  #include <iostream>
 
 #include <string>
 
 using namespace std; 
 
 
 
 class Student { 
 
 public: 
 
 Student() {} 
 
 Student( const string& nm, int sc = 0 ) 
 
 : name( nm ), score( sc ) {} 
 
 
 
 void set_student( const string& nm, int sc = 0 ) 
 
 { 
 
 name = nm; 
 
 score = sc; 
 
 } 
 
 
 
 const string& get_name() const 
 
 { 
 
 return name; 
 
 } 
 
 
 
 int get_score() const 
 
 { 
 
 return score; 
 
 } 
 
 
 
 private: 
 
 string name; 
 
 int score; 
 
 }; 
 
 
 
 // output student's name and score 
 
 void output_student( const Student& student ) 
 
 { 
 
 cout << student.get_name() << "/t"; 
 
 cout << student.get_score() << endl; 
 
 } 
 
 
 
 int main() 
 
 { 
 
 Student stu( "Wang", 85 ); 
 
 output_student( stu ); 
 
 }
 设 计了一个类 Student，数据成员有 name 和 score，有两个构造函数，有一个设置成员数据函数 set_student()，各有一个取得 name 和 score 的函数 get_name() 和 get_score()。请注意 get_name() 和 get_score() 后面都加了 const，而 set_student() 后面没有（也不能有const）。

 

 首先说一点题外话，为什么 get_name() 前面也加 const。如果没有前后两个 const 的话，get_name() 返回的是对私有数据成员 name 的引用，所以通过这个引用可以改变私有成员 name 的值，如

 

 
 
 

  CODE:
 
 
 

  [Copy to clipboard]
 
 
 

    Student stu( "Wang", 85 );
 
 stu.get_name() = "Li";
 即把 name 由原来的 "Wang" 变成了 "Li"，而这不是我们希望的发生的。所以在 get_name() 前面加 const 避免这种情况的发生。

 

 那么，get_name() 和 get_score() 这两个后面应该加 const的成员函数，如果没有 const 修饰的话可不可以呢？回答是可以！但是这样做的代价是：const对象将不能再调用这两个非const成员函数了。如

 

 
 
 

  CODE:
 
 
 

  [Copy to clipboard]
 
 
 

  const string& get_name(); // 这两个函数都应该设成 const 型
 
 int get_score();
 
 void output_student( const Student& student ) 
 
 { 
 
 cout << student.get_name() << "/t"; // 如果 get_name() 和 get_score() 是非const成员函数，这一句和下一句调用是错误的
 
 cout << student.get_score() << endl; 
 
 }
 由 于参数student表示的是一个对const Student型对象的引用，所以 student 不能调用非const成员函数如 set_student()。如果 get_name() 和 get_score() 成员函数也变成非const型，那么上面的 student.get_name() 和 student.get_score() 的使用就是非法的，这样就会给我们处理问题造成困难。

 

 因此，我们没有理由反对使用const，该加const时就应该加上const，这样使成员函数除了非const的对象之外，const对象也能够调用 它。

枚举的概述：
 枚举是在一定范围内取值,并且这个值必须是枚举类型中的任意一个,并且只能有一个
 特点:
 1.必须在规定范围内取值
 2.这个值只能取一个
 3.这个值可以是规定范围内的任意一个
 枚举的本质就是一个Java类
 枚举的引入
 
public class EnumDemo01 {
//	private int state;
//	private GAME2 state;
//	private GAME3 state;
   private GAME4 state;
   
   public void test() {
//		state = GAME.START;
//		state = -1;
   	
//		state = GAME2.VICTORY;
//		state = new GAME2();
   	
//		state = GAME3.END;
//		state = new GAME3();
//		state = -1;
   	
   	state = GAME4.DEFEAT;
//		state = new GAME4();
//		state = -1;
   }
}

// 版本一
class GAME{
   public static final int START = 0x0001;
   public static final int END = 0x0002;
   public static final int RUNNING = 0x0003;
   public static final int STOP = 0x0004;
   public static final int VICTORY = 0x0005;
   public static final int DEFEAT = 0x0006;
   
}

// 版本二
class GAME2{
   public static final GAME2 START = new GAME2();
   public static final GAME2 END = new GAME2();
   public static final GAME2 RUNNING = new GAME2();
   public static final GAME2 STOP = new GAME2();
   public static final GAME2 VICTORY = new GAME2();
   public static final GAME2 DEFEAT = new GAME2();
}

// 版本三
class GAME3{
   
   private GAME3() {}
   
   public static final GAME3 START = new GAME3();
   public static final GAME3 END = new GAME3();
   public static final GAME3 RUNNING = new GAME3();
   public static final GAME3 STOP = new GAME3();
   public static final GAME3 VICTORY = new GAME3();
   public static final GAME3 DEFEAT = new GAME3();
}

// 版本四
enum GAME4{
   START, END, RUNNING, STOP, VICTORY, DEFEAT
}

 
枚举的特点
 枚举既然是一个类,那么枚举是否有构造方法，成员方法，静态方法，静态变量，成员变量，抽象方法?
 有的话，有意义吗?
 1.枚举中所有的成员，必须出现在枚举对象的下面
 2.如果枚举类中有一个成员，那么枚举对象最后不能省略分号
 3.枚举中构造方法必须私有
 4.抽象方法有意义 - 可以用来描述某个枚举成员的信息，提高程序的可读性
 5.枚举也是switch语句 的常量形式之一
 switch语句中可以有哪些?
 byte short int char String 枚举
 
举例代码如下
 
public class EnumDemo02 {
	public static void main(String[] args) {
		Color c = Color.GREEN;
//		c.show();
//		Color.RED.desc();

		switch (c) {
		case RED:
			Color.RED.desc();
			break;
		case GREEN:
			Color.GREEN.desc();
			break;
		case YELLOW:
			Color.YELLOW.desc();
			break;

		default:
			break;
		}
	}
}

enum Color {
	RED {

		@Override
		public void desc() {
			System.out.println("我是红色");
		}

	},
	GREEN {

		@Override
		public void desc() {
			System.out.println("我是绿色");
		}

	},
	YELLOW {
		@Override
		public void desc() {
			System.out.println("我是黄色");
		}
	};
	public int num;
	public final static int A = 10;

	private Color() {
	}

	private Color(int num) {
		this.num = num;
	}

	public void show() {
		System.out.println("show");
	}

	public abstract void desc();
}

 
枚举中常用的方法
 String name()
 返回此枚举常量的名称，与其枚举声明中声明的完全相同。
 int ordinal()
 返回此枚举常数的序数（其枚举声明中的位置，其中初始常数的序数为零）。
 static <T extends Enum>
 T valueOf(类 enumType, String name)
 返回具有指定名称的指定枚举类型的枚举常量。
 T valueOf(String name)
 T[] values();
 需求: 实现枚举对象 、 枚举下标、 枚举名称之间的相互转换
 代码实现如下
 
public class EnumDemo03 {
   public static void main(String[] args) {
//		method01(TrafficLight.GREEN);
//		method02("GREEN");
//		method03(2);
   	
   	TrafficLight t = TrafficLight.valueOf(TrafficLight.class, "GREEN");
   	System.out.println(t);
   }

   /**
    * 已知枚举的下标，获取枚举的名称，枚举的对象
    */
   public static void method03(int index) {
   	// values方法返回枚举数组
   	TrafficLight trafficLight = TrafficLight.values()[index];
   	System.out.println(trafficLight);
   	String name = trafficLight.name();
   	System.out.println(name);
   }

   /**
    * 已知枚举的名称，获取枚举的下标和枚举对象
    */
   public static void method02(String name) {
   	// T valueOf(String name)
   	TrafficLight trafficLight = TrafficLight.valueOf(name);
   	int index = trafficLight.ordinal();
   	System.out.println(trafficLight + ":" + index);
   }

   /**
    * 已知枚举对象，获取枚举的下标和名称
    */
   public static void method01(Enum<TrafficLight> e) {
   	System.out.println(e.ordinal() + ":" + e.name());
   }
}

enum TrafficLight{
   RED, GREEN, YELLOW
}
 
需求：使用枚举来描述一个星期多少天，并且要使用switch测试，要求枚举中用抽象方法来描述每一天
 
代码实现如下
 
public enum Weekend {

	MONDAY {
		@Override
		void desc() {
			System.out.println("星期一");
		}
	},
	TUESDAY {
		@Override
		void desc() {
			System.out.println("星期二");
		}
	},
	WEDNESDAY {
		@Override
		void desc() {
			System.out.println("星期三");
		}
	},
	THURSDAY {
		@Override
		void desc() {
			System.out.println("星期四");
		}
	},
	FRIDAY {
		@Override
		void desc() {
			System.out.println("星期五");
		}
	},
	SATURDAY {
		@Override
		void desc() {
			System.out.println("星期六");
		}
	},
	SUNDAY {
		@Override
		void desc() {
			System.out.println("星期天");
		}
	};

	abstract void desc();

	@Deprecated
	public static void main(String[] args) {
		Weekend day = Weekend.SATURDAY;
		switch (day) {
		case MONDAY:
			Weekend.MONDAY.desc();
			break;
		case TUESDAY:
			Weekend.TUESDAY.desc();
			break;
		case WEDNESDAY:
			Weekend.WEDNESDAY.desc();
			break;
		case THURSDAY:
			Weekend.THURSDAY.desc();
			break;
		case FRIDAY:
			Weekend.FRIDAY.desc();
			break;
		case SATURDAY:
			Weekend.SATURDAY.desc();
			break;
		case SUNDAY:
			Weekend.SUNDAY.desc();
			break;

		default:
			System.out.println("非法星期");
			break;
		}

	}
}