C++ 枚举、const、static的用法
一、类中枚举
1.类中定义常量
写法一：使用枚举 enum 枚举类型的名字{black,white}; //枚举不占用类的大小
class Cat
{
protected:
enum 枚举类型的名字{red,black,white};
};
示例代码：
#include <iostream>
class Cat {
public:
enum Color {
Black,
White,
Brown
};
Cat(Color c) : color(c)
{
}
Color getColor()
{
return color; // 返回枚举值
}
private:
Color color;
};
int main(int argc, char const *argv[])
{
Cat cat(Cat::Brown);
std::cout<<"getColor:"<<cat.getColor()<<std::endl;
std::cout<<"Cat::Black:"<<Cat::Black<<std::endl;
std::cout<<"Cat::White:"<<Cat::White<<std::endl;
std::cout<<"Cat::Brown:"<<Cat::Brown<<std::endl;
// 定义枚举变量
enum Cat::Color color = Cat::Black;
std::cout<<"color:"<<color<<std::endl;
return 0;
}
/*
执行结果：
getColor:2
Cat::Black:0
Cat::White:1
Cat::Brown:2
color:0
*/
写法二： static const int n=100; //静态常量(具备了const和static的双重属性)，直接在类中初始化
二、const和static的用途
1. const的用途
1.1 const修饰成员变量
作用：表示常量
两种初始化的写法：
- 写法1：通过在类的定义中直接赋值(C++11新增的特性，老的C++标准不允许)
- 写法2：在构造函数的参数列表初始化中赋值
示例代码：
#include <iostream>
/* const修饰成员变量
早期的C++标准，不允许在类的定义中直接给成员变量赋初始值
*/
class Circle{
public:
//写法2：const修饰成员变量必须在构造函数的参数列表中初始化赋值
Circle():radius(1.0),pi(3.14)
{}
// 错误的：若const修饰的变量未在定义时初始化，则必须在构造函数的初始化列表中初始化
// Circle()
// {
// radius = 1.0;
// pi = 3.14;
// }
private:
// const修饰成员变量，表示成员变量是一个常量，一旦初始化后就不能修改
//写法1：利用C++11的新规则，允许在类的定义中直接给成员变量赋初始值
// const float pi = 3.14;
//写法2：const修饰成员变量必须在构造函数的参数列表中初始化赋值
const float pi;
float radius;
};
int main(int argc, char const *argv[])
{
return 0;
}
1.2 const修饰成员函数(非成员函数不能用const修饰)
写法：
返回值 函数名() const //const放在函数声明的后面(C语言没有这种写法)
作用：
- 防止该成员函数修改类的成员变量
- 不论成员变量是const修饰，还是普通变量，都不能修改，只能访问 const
修饰函数的返回值
const int fun() //等价于int const fun()
示例代码：
#include <iostream>
/*
const修饰成员函数
*/
class Circle{
public:
//写法2：const修饰成员变量必须在构造函数的参数列表中初始化赋值
Circle():radius(1.5),pi(3.14)
{}
void show() const
{
// radius = 2.0; // 编译报错：const修饰的成员函数不能修改成员变量
std::cout << "radius = " << radius << std::endl;
}
private:
const float pi;
float radius;
};
// 普通函数（不属于类的成员函数）不用用const修饰
// error: non-member function ‘void test()’ cannot have cv-qualifier
void test() const
{
}
int main(int argc, char const *argv[])
{
Circle c1;
c1.show();
return 0;
}
1.3 const修饰引用
常引用，表示该引用不能修改指向的变量
示例代码：
#include <iostream>
int main() {
// 原始变量（非常量）
int original = 42;
// 创建常引用绑定到原始变量
const int& constRef = original;
// 读取原始值 - 允许
std::cout << "原始值: " << constRef << std::endl; // 输出: 42
// 尝试修改 - 编译错误！
// constRef = 100; // 错误：无法通过常引用修改
// 直接修改原始变量 - 允许（因为原始变量是非常量）
original = 100;
// 常引用看到的值也随之改变
std::cout << "修改后的值: " << constRef << std::endl; // 输出: 100
// 创建常量对象
const int constValue = 200;
// 常引用绑定到常量对象 - 允许
const int& constRef2 = constValue;
// 尝试修改 - 编译错误！（双重保护）
// constRef2 = 300; // 错误
return 0;
}
2. static的用途
静态成员：类的成员使用static修饰，那么就是静态成员
2.1 修饰成员变量
- 静态成员数据需要在类的外面初始化赋值
- 静态成员数据是该类所有的对象共享的(所有的对象使用同一个静态成员)
- 静态成员数据不占用类的地址空间，类的大小不包含静态成员数据的大小
实际作用：静态成员变量可以理解为类中所有对象共享的"全局变量"，可以用来在同一个类的对象之间传递信息
示例代码：修饰成员变量
#include <iostream>
/*
static修饰成员变量(静态成员变量)
*/
class Circle{
public:
Circle()
{
cnt++;
std::cout << "创建的Circle对象个数:"<< cnt << std::endl;
}
void func()
{
cnt = 100;
}
void show()
{
std::cout << "cnt = " << cnt << std::endl;
}
private:
static int cnt;
};
int Circle::cnt = 0;
int main(int argc, char const *argv[])
{
Circle c3;
Circle c2;
Circle c1;
c1.func();
c2.show();
c3.show();
return 0;
}
/*
执行结果：
创建的Circle对象个数:1
创建的Circle对象个数:2
创建的Circle对象个数:3
cnt = 100
cnt = 100
*/
2.2 修饰成员函数
- 静态成员函数可以通过类名直接调用(不需要定义对象，直接用类名即可调用)
- 静态成员函数中只能使用static修饰的成员变量，非static修饰不能使用
应用：作为工具类使用
工具类：该类专门提供算法函数给别人使用
class Math公式 //工具类
{
public:
static 求偏导数();
static 求积分();
static 求无人机飞行加速度和角速度();
}；
使用：
Math公式::求偏导数(); //不需要定义对象，直接调用
示例代码1：静态成员函数可以通过类名直接调用
#include <iostream>
/*
静态成员函数可以通过类名直接调用
*/
class Circle{
public:
Circle()
{
// cnt++;
std::cout << "创建的Circle对象" << std::endl;
}
static void func()
{
cnt = 100;
std::cout << "static void func()"<<" cnt = " << cnt << std::endl;
}
void show()
{
std::cout << "cnt = " << cnt << std::endl;
}
private:
static int cnt;
};
int Circle::cnt = 0;
int main(int argc, char const *argv[])
{
// 通过类名调用静态成员函数
Circle::func();
// 通过对象调用静态成员函数
Circle c1;
c1.func();
return 0;
}
/*
执行结果：
static void func() cnt = 100
创建的Circle对象
static void func() cnt = 100
*/
示例代码2：静态成员函数中只能使用static修饰的成员变量
#include <iostream>
/*
静态成员函数中只能使用static修饰的成员变量，非static修饰不能使用
*/
class Circle{
public:
Circle()
{
// cnt++;
std::cout << "创建的Circle对象" << std::endl;
}
static void func()
{
cnt = 100;
r = 12; // 报错 error: invalid use of member ‘Circle::r’ in static member function
std::cout << "static void func()"<<" cnt = " << cnt << std::endl;
}
void show()
{
std::cout << "cnt = " << cnt << std::endl;
}
private:
static int cnt;
int r;
};
int Circle::cnt = 0;
int main(int argc, char const *argv[])
{
// 通过类名调用静态成员函数
Circle::func();
// 通过对象调用静态成员函数
Circle c1;
c1.func();
return 0;
}