1）const定义的常量在超出其作用域之后其空间会被释放，而static定义的静态常量在函数执行后不会释放其存储空间
void f1()
{
const int x=1;
cout<<x<<endl;
}
void f2()
{
static int y=2;
cout<<y<<endl;
y++;
}
int main()
{
f1();//1
f1();//1 const定义的常量在超出其作用域之后其空间会被释放
f2();//2
f2();//3 static定义的静态常量在函数执行后不会释放其存储空间
}
2）static静态成员变量不能在类的内部初始化，在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，比如：double Account::Rate = 2.25，static关键字只能用于类定义体内部的声明中，并且在外部定义时不能标识为static
class A
{
private: static int x;//static成员变量只能在内部声明，定义需要放在类的外部 public:
void f()
{
cout<<x<<endl;
}
}; //error 外部定义时不能标识为static
//static int A::x=10; int A::x=10;//在类的外部定义该static成员变量 int main()
{
A a;
a.f();//10
}
3）static表示的是静态的，类的静态成员函数，静态成员变量是和类相关的，而不是和类的具体对象相关的，即使没有具体对象，也能调用类的静态成员函数和静态成员变量。一般类的静态成员函数就相当于一个全局函数，只不过它的作用域限定于包含它的文件中
class A
{
public:
static int x;
static void test()
{
cout<<"test"<<endl;
}
void f()
{
cout<<x<<endl;
}
}; int A::x=10; int main()
{
//即使没有具体对象，也能调用类的静态成员函数和静态成员变量
cout<<A::x<<endl;//10
A::test();//test A a1;
a1.f();//10 A a2;
a2.f();//10 类的静态成员变量和对象无关，只和类有关
}
4）const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数
const成员变量只在某个对象生存期内是常量，而对于整个类而言却可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同，所以不能在类的声明中初始化const数据成员，因为类的对象没有被创建时，编译器不知道const数据成员的值是什么
class A
{
private:
//const int x=1;
//const int y=2; //错误的做法：在这里初始化虽然语义可以通过，但是还是会被构造函数中的值覆盖
const int x;
const int y;
public:
void f()
{
cout<<x<<" "<<y<<endl;
} A(int a,int b):x(a),y(b)//通过构造函数初始化列表来初始化const成员变量，而且必须要有构造函数
{ }; }; int main()
{
A a1(10,20);
a1.f();//10 20 A a2(11,21);
a2.f();//11 21
}
6）const数据成员的初始化只能在类的构造函数的初始化列表中进行，要想建立在整个类中都恒定的常量，应该用类中的枚举常量实现，或者static const
class A
{
private:
const int x;
const int y;
public:
void f()
{
cout<<x<<" "<<y<<endl;
}
enum{x1=100,y1=200}; A(int a,int b):x(x1),y(y1)//通过枚举常量进行恒定初始化，传入的a和b根本没有用到
{ };
}; int main()
{
A a1(10,20);
a1.f();//100 200 A a2(11,21);
a2.f();//100 200
}
class A
{
private:
const int x;
const int y;
public:
void f()
{
cout<<x<<" "<<y<<endl;
}
static int x2,y2; A(int a,int b):x(x2),y(y2)//通过static成员变量进行恒定初始化,传入的a和b也没有起到作用
{ };
}; int A::x2=300;
int A::y2=400; int main()
{
A a1(10,20);
a1.f();//300 400 A a2(11,21);
a2.f();//300 400
}
7）const成员函数的主要目的是防止成员函数修改对象内容，即const成员函数不能修改成员变量的值，但是可以访问成员变量
class A
{
private:
int x=2;
public:
int p() const
{
//x=3;//error const成员函数不能修改成员变量
return x;//但是可以访问成员变量
}
void f()
{
cout<<x<<endl;
} }; int main()
{
A a1;
cout<<a1.p()<<endl;//2
a1.f();//2
}
8）static成员函数的主要目的是作为类作用域的全局函数，不能访问类的非静态数据成员，因为类的静态成员函数没有this指针，这导致：1.不能直接存取类的非静态成员变量，调用非静态成员函数，2.不能被声明为虚函数(没有this指针，实现不了多态，定义为虚函数没有意义）
class A
{
public:
int x=2;
void f()
{
cout<<x<<endl;
}
static int p()
{
int k=3;
// k=x; //error 不能直接存取非静态成员变量
// f(); //error 不能直接调用非静态成员函数
return k;
}
}; int main()
{
A a1;
cout<<a1.p()<<endl;//3
a1.f();//2
}
9)类的const static或static const成员变量必须在哪里初始化？
必须在类的外部进行定义初始化
class A
{
private:
static const int x;
const static int y;//哪个关键字在前无所谓，x和y的含义是相同的
public:
void f()
{
cout<<x<<" "<<y<<endl;
} }; const int A::x=300;//不能加static关键字，但是必须加const关键字
const int A::y=400; int main()
{
A a1;
a1.f();//300 400 A a2;
a2.f();//300 400
}