程序代码：

inline int a=100;
void func()
{
  std::cout<<a
}

程序代码：

void func();
inline int a=200;
int main()
{
  func();
|

程序代码：

    关键字：
        inline
        
    概述：
        如果一些函数被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。为了解决这个问题，特别的引入了inline修饰符，表示为内联函数。
        
    解析：
        在程序编译阶段，编译器把每次调用函数的地方直接替换为函数体中的代码，避免频繁的开辟函数栈。
        
    注：
        内联函数中不能包含有 循环语句、switch语句、goto语句、数组、递归函数，如果包含则忽略关键字inline，即为非内联函数
        
    语法：
        inline 返回值类型 函数名(参数列表)
        {
            //函数体
        }
        
    示例：
        
        #include <stdio.h>  
         
        //函数定义为inline即:内联函数  
        inline char* dbtest(int a) 
        {  
            return (i % 2 > 0) ? "奇" : "偶";  
        }   
          
        int main()  
        {  
            int i = 0;  
            for (i=1; i < 100; i++) 
            {
                //把 函数调用 dbtest(i)  替换为 函数体中的代码 (i % 2 > 0) ? "奇" : "偶";
                printf("i:%d    奇偶性:%s /n", i, dbtest(i));      
            }  
        }

    

程序代码：

    关键字：
        static
        
    概述:
        在变量定义时就分配好存储单元并保持不变，直至整个程序结束才销毁.可分为静态局部变量和静态全局变量
        
        
    解析：
        静态局部变量:
            在程序中的该程序块区域中可以访问的变量，函数结束不销毁,保留原值。该源程序结束时销毁
            
        特性:
            该变量在全局数据区分配内存；
            静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
            静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；
            它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；
            
            
        静态全局变量:
            在程序中的该源文件中可以访问的变量，该源文件结束时销毁
            
            
            作用域：
                当前文件中
                
    注:
        1. 静态成员只能访问静态成员，不能访问非静态成员, 可以使用实例化指针访问
        2. 实例成员可以访问静态成员，和实例成员
        
        
        
    示例：
        1. 静态/非静态局部变量
            #include <stdio.h>
            #include<stdlib.h>

            int main()
            {
                void test();

                for (int i = 0; i < 5; i++)
                {
                    test();
                }
                    
                system("pause");
                return 0;
            }

            void test()
            {

                //非静态局部变量(auto),默认方式, 每次调用不保留原值
                int x = 0;
                
                //静态局部变量(static),函数结束时不销毁,保留原值,文件结束时销毁
                static int y = 0;

                x++;
                y++;

                printf_s("x = %d, y = %d\n", x, y);
            }
            
            =======================运行结果=======================
            x = 1, y = 1
            x = 1, y = 2
            x = 1, y = 3
            x = 1, y = 4
            x = 1, y = 5
        
        

        2. 同文件中类的静态成员变量/函数
            #include <iostream>
            #include <cstdlib>
            using namespace std;

            class Cname
            {
            public:
                Cname(int x)
                {
                    a = x;
                }

                int print()
                {
                    return this->a + this->c;
                }

                //静态成员函数
                static void yy()
                {
                    //访问静态成员 不可以使用this指针
                    // this -> c
                    cout << "静态成员函数 c = " << c << endl;
                }

            private:
                int a;
                //类的静态私有(初始化需要在类外初始化)
                //静态变量定义后基值不会改变，直至整个程序结束才销毁
                static int c;

            public:
                static int d;
            };

            int Cname::d = 10;

            //初始化Cname类成员变量 c 的值
            // :: 作用域操作符
            int Cname::c = 5;

            int main()
            {

                Cname c1(10);
                Cname c2(20);
                cout << "对象 c1的返回值：" << c1.print() << endl;
                cout << "对象 c2的返回值：" << c2.print() << endl;

                c2.yy();

                cout << Cname::d << endl;
                system("pause");
                return 0;
            }
        
        
        3. 类的静态成员声明及初始化
            cmy.h==================================================
                #pragma once
                class cmy
                {
                public:
                    cmy();
                    ~cmy();

                    static int c;
                    static void test();
                };
            cmy.cpp===================================================
                #include "stdafx.h"
                #include "cmy.h"

                // 声明静态成员并初始化
                int cmy::c = 10;

                // 声明静态成员
                cmy::cmy()
                {
                }

                cmy::~cmy()
                {
                }


                void cmy::test()
                {
                    printf("类的静态函数");
                }
            主函数=====================================================            
                #include "stdafx.h"
                #include "cmy.h"
                #include <stdlib.h>

                int main()
                {

                    cmy m_cmy;

                    m_cmy.test();
                    printf("类的静态成员 %d\n", m_cmy.c);

                    system("pause");
                    return 0;
                }
        
        4. 类的静态成员访问非静态成员
            1. 函数传递
                class Cmy{
                    void test(Cmy *m_cmy)
                    {
                        m_cmy-> 非静态成员;
                    }
                }
                
                static Cmy m_my;
                m_my.test(&m_my);
            
            2. this指针传递(或使用构造函数，或非静态函数)
                class Cmy{
                    void test1()
                    {
                        m_cmy = this;
                    }
                    static void test2()
                    {
                        m_cmy-> 非静态成员;
                    }
                    
                    static Cmy *m_cmy
                }
            
            3. 全局变量(不推荐)
                Cmy m_my;
                class Cmy{
                
                }
        
        
        4. 导入外部的静态成员
            注：只允许本文件使用
            
            ===================================a.cpp=========================================
            #include<stdio.h>
            #include<stdlib.h>

            //导入外部静态变量
            extern int a;

            //导入外部静态函数
            extern void test();

            //声明外部非静态函数
            extern void test2();

            int main()
            {
                //外部静态变量，不允许跨文件使用
                //++a;

                //外部静态函数，不允许跨文件使用
                //test();

                //调用外部函数
                test2();

                system("pause");
                return 0;
            }
            ===================================b.cpp=========================================
            #include <stdio.h>

            //定义外部静态全局变量 - 只允许本文件使用
            static int a = 10;

            //定义外部静态函数 - 史允许本文件使用
            static void test()
            {
                printf_s("外部的函数 a = %d\n", a);
            }

            //非静态函数
            void test2()
            {
                test();
            }
            ==================================================================================