void ShowName ( ) { cout << "Name\t" << Student :: name << endl ; } public : Student ( string n , int id ) : name ( n ) , ID ( id ) { } //派生类 class Person : public Student { public : Person ( string n , int id ) : Student ( n , id ) { } void show ( ) { //cout << "Name\t" << Student::name << endl;//错误 name是私有成员 ShowName ( ) ; cout << "ID\t" << Student :: ID << endl ;

二、static

1. 静态成员变量

· 必须在类外使用 数据类型 类名::静态变量名; 定义

· 若定义在类的public域,类外可以访问它

2. 静态成员函数

· 静态成员函数 只能访问静态成员变量

class MyClass{
	int x;
	static int y;
public:
	static int z;
	void show(){
		cout<<"x\t"<<x<<endl;
		//非静态成员函数可以访问静态成员变量
		cout<<"y\t"<<y<<endl;
		cout<<"z\t"<<z<<endl;
	static void s_show(){
		//cout<<"x\t"<<x<<endl;//错误 静态成员函数不能访问非静态成员变量
  		cout<<"y\t"<<y<<endl;
		cout<<"z\t"<<z<<endl;
	MyClass(int x,int y,int z):x(x)/*,y(y) 错误 y 不是 MyClass 的非静态数据成员或基类*/
	{this->y=y;	this->z=z;}//正确
//int MyClass::x;//错误 非静态数据成员不能在其类的外部定义
int MyClass::y;
int MyClass::z;
三、成员指针
 
1. 成员变量的指针
 
· 定义: 数据类型*指针名=&对象名.成员变量名;
 
2. 成员函数的指针
 
· 定义: 返回值类型 (类名:: * 指针名)(形参);
 
· 使用成员函数的指针前,须先创建对象
 
class Point {
 	int X, Y;
public:
	int n;
 	void Set_XY(int x, int y) { X = x; Y = y; }
 	void display() { cout << "X=" << X << ",Y=" << Y << endl; }
void main() {
	//成员函数指针的定义
 	void (Point:: * p2)(int, int);
 	p2 = &Point::Set_XY;
 	void (Point:: * p3)() = &Point::display;
 	//未创建对象 不能使用
 	Point c;
 	Point* p1 = &c; //对象指针
 	p1->Set_XY(1, 1); //使用指针调用成员函数
 	int* pn = &c.n; //使用成员变量指针访问成员变量
	*pn = 10; 
	(c.*p3)(); //使用成员函数指针调用成员函数display
	(c.*p2)(2, 3); //使用成员函数指针调用成员函数Set_XY
	(c.*p3)();
	system("pause");
四、const
 
1. 常对象
 
· 定义: const 类名 对象名;
 
· 不能修改非static成员变量
 
· 不能调用非static/const成员函数,防止修改数据
 
2. 常成员函数
 
· 定义: 返回值类型 函数名(形参) const{}
 
· 不能修改非static成员变量
 
· 可以访问该类的所有成员变量
 
3. 常成员变量
 
· 用法与一般常变量一样
 
class MyClass {
public:
    int x;
    static int y;
    const int z;
    void show() {}
    static void s_show() {
       	//cout<<"x\t"<<x<<endl;//错误 静态成员函数不能访问非静态成员变量
        cout << "y\t" << y << endl;
        cout << "z\t" << z << endl;
    void c_show() const {
        //x++; //错误 不可修改非static成员变量
        y++;
        cout << "x\t" << x << endl;
        cout << "y\t" << y << endl;
        cout << "z\t" << z << endl;
    MyClass(int x = 1, int y = 2, int z = 3) :x(x)/*,y(y) 错误*/,z(z)
    { this->y = y; /*this->z = z; 错误 应使用构造函数初始化表*/ }
int MyClass::y;//静态数据成员必须在其类的外部定义
void main(){
	const MyClass A;
	//MyClass const A //与上一条语句等价
	//A.x++; //错误 常对象不能修改非static成员变量
	A.y++; //正确
	//A.show(); //错误 常对象不能调用非static/const成员函数
	A.s_show(); //正确
	A.c_show();
1. 友元函数
 
· 声明: friend 返回值类型 函数名(形参);
 
· 友元函数不是该类的成员函数
 
· 友元函数可以访问该类的私有成员
 
class Point {
 	int x, y;
public:
 	Point(int xx = 0, int yy = 0) :x(xx), y(yy) {}
 	int GetX() { return x; }
 	int GetY() { return y; }
 	friend double Distance(Point& a, Point& b); //须在类中声明它的友元
double Distance(Point& a, Point& b) {
 	double dx = a.x - b.x;
 	double dy = a.y - b.y;
 	return sqrt(dx * dx + dy * dy);
2. 友元类
 
· 声明: friend class 类名;
 
· 如果B是A的友元类,则B类的所有成员函数都可访问A类的私有成员
 
class A {
 	int x;
 	void Display() { cout << x << endl; }
 	friend class B;
class B{
	A a;
public:
	void Set(int i) { a.x = i; }
 	void Display() { a.Display();}
//去掉内嵌对象a,修改两个成员函数
class A {
  	static int x;
    	static void Display() { cout << x << endl; }
    	friend class B;
class B {
public:
	void Set(int i) { A::x = i; }
    	void Display() { A::Display(); }
六、关于报错: 非静态成员的引用必须与特定对象相对
 
原因: 类的成员分为实例成员和静态成员,他们的储存空间不同
 
实例成员: 储存空间属于具体的实例(对象),不同实例名下的成员有不同的储存空间
 访问实例成员
 不能用 ClassName::MemberName
 只能用 Object.MemberName
 
静态成员: 储存空间是固定的,与具体的实例无关,被该类的所有对象共享
 访问静态成员
 可以用 ClassName::MemberName
 也可以用 Object.MemberName
                                    前面曾写过一篇恼人的函数指针（一），总结了普通函数指针的声明、定义以及调用，还有函数指针数组，函数指针用作返回值等。但是作为C++的研读，我发现我漏掉了一个最重要的内容，就是指向类成员的指针，这里将做相应补充（相关代码测试环境为vs 2010）。
指向类成员的指针总的来讲可以分为两大类四小类（指向数据成员还是成员函数，指向普通成员还是静态成员），下面一一做介绍：
一、指向类的普通成员的指针（非静态）
1、指向类成员函数的指针
简单的讲，指向类成员函数的指针与普通函数指针的区别在于，前者不仅要匹配函数的参数类型和个数以及返回值类型，还要匹配该函数指针所属的类类型。总结一下，比较以下几点：
                                    1 关于继承：不可否认良好的抽象设计可以让程序更清晰，代码更看起来更好，但是她也是有损失的，在继承体系中子类的创建会调用父类的构造函数，销毁时会调用父类的析构函数，这种消耗会随着继承的深度直线上升，所以不要过度的抽象和继承。
2 对象的复合：对象的复合和继承很相似，当一个对象包含其他对象构造时也会引起额外的构造。关于这点可能会有很多人不解，认为这是不可避免的，举个例子，你的一个对象中用到数组和字符串，你是选择string和vector还是char＊ 和c系的数组呢，如果没有用到c++stl库提供的相关的高级用法，建议选择后者。
3 构造函数：尽量用参数列表初始化代替参数，避免值传递初始化。
                                    static 数据成员必须在类定义的外部定义。不象普通数据成员，static成员不是通过类构造函数进行初始化，而是应该在定义时进行初始化。静态数据成员的用途之一是统计有多少个对象实际存在。静态数据成员不能在类中初始化，实际上类定义只是在描述对象的蓝图，在其中指定初值是不允许的。也不能在构造函数中初始化该成员，因为静态数据成员为类的各个对象共享，那么每次创建一个类的对象则静态数据成员都要被重新初始化
                                    C++类有几种类型的数据成员：普通类型、常量(const)、静态(static)、静态常量(static const)。这里分别探讨以下他们在C++11之前和之后的初始化方式。
c++11之前版本的初始化
在C++11之前常规的数据成员变量只能在构造函数里和初始化列表里进行初始化。const类型的成员变量只能在初始化列表里并且必须在这里进行初始化。static类型只能在类外进行初始化。static...
                                    定义类时实际上是定义了一种数据类型，编译程序并不为数据类型分配存储空间。只有在说明对象时才为对象的每个成员分配空间，并把占有的空间当一个整体来看待。当我们将类的一个成员存储类型指定为静态类型时，则由该类所产生的所有对象均共享为其静态成员所分配的一个存储空间。换言之，在说明对象时，并不为静态类型的成员分配空间。
1.静态数据成员
      静态数据成员注意一下几点：
    （1）类的静态成
                                    文章目录存储类说明符关键字C/C++程序内存的分配程序运行时内存占用情况三种内存分配方式C语言static关键字（面向过程设计）静态全局变量静态局部变量静态函数C++类中static关键字（面向对象设计）静态成员变量静态成员函数
static关键字是一种存储类说明符，有两个作用，限定作用域和保持变量内容持久化；它延长了变量的生命周期，但是缩小了作用域。下面将详细介绍与它相关的知识点。
存储类说明符关键字
存储类说明符用来定义 C / C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所
                                    如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：  
1. 要创建嵌套类的对象，并不需要其外围类的对象。  
2. 不能从嵌套类的对象...
                                    在对变量声明时，全局变量可以实现对象的共享，但是可以被任意修改，没有权限的修改会出现无章法的问题。而普通成员变量是本类某个对象独有的，在类作用域内发挥作用，不会被任意修改，相比于全局变量更加安全，可以在外部不能被使用，因此产生了。第一次遇到b进行初始化，每次在调用fn时都要对a进行初始化，而b在静态存储区开辟的空间没有消息，在循环内累加，直到程序运行完空间才释放。，非静态函数内pintf()有this指针，必须通过对象来调用，把地址传过来才知道是谁的，不然就乱了。虽然b的空间没有消失，但是b是。
static关键字在c语言中比较常用，使用恰当能够大大提高程序的模块化特性，有利于扩展和维护。 
但是对于c语言初学者，static由于使用灵活，并不容易掌握。本文就static在c语言中的应用进行总结，供参考使用。错漏之处，请不吝指正。 
最后一节加入了c++面向对象中static的使用特性，当作拓展阅...
                                    综合而言，C++中类的初始化操作有四个部分组成：1.初始化列表：所有类非静态数据成员都可以在这里初始化，        所有类静态数据成员都不能在这里初始化
2.构造函数体：对于类非静态数据成员：            const型成员不能在这里初始化            引用型成员不能在这里初始化
            没有默认构造函数的成员不能在这里初始化
        对于类静态数据成员