局部变量&全局变量
 
局部变量
定义
  
全局变量
定义
全局函数不可以使用成员变量的数据
A类中使用全局函数
A类中使用全局变量
example1
结果
  
static用途

 
局部变量
 
定义
 
定义在函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 离开该函数后就是无效的，再使用就会报错
 
//可以直接声明定义，也可以分开写
//如果变量不多，非该类的函数，可以直接在唯一一个源函数上定义
int f1(int a){
    int b,c;  //b,c仅在函数f1()内有效
    return a+b+c;
}
int main(){
    int m,n;  //m,n仅在函数main()内有效
    return 0;
}
 
 
main 函数中定义的变量也是局部变量，只能在 main 函数中使用；同时，main 函数中也不能使用其它函数中定义的变量。main 函数也是一个函数，与其它函数地位平等。
 如果要使用，可以通过指针，B类成为main类的成员函数
 
 
形参变量、在函数体内定义的变量都是局部变量。实参给形参传值的过程也就是给局部变量赋值的过程。
 
 
可以在不同的函数中使用相同的变量名，它们表示不同的数据，分配不同的内存，互不干扰，也不会发生混淆。
 
 
在语句块中也可定义变量，它的作用域只限于当前语句块
 
 
全局变量
 
定义
 
在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的源文件，包括 .c 和 .h 文件。
 
#include <stdio.h>
int n = 10;  //全局变量

void func1(){
    int n = 20;  //局部变量
    printf("func1 n: %d\n", n);
}

void func2(int n){
    printf("func2 n: %d\n", n);
}

void func3(){
    printf("func3 n: %d\n", n);
}

int main(){
    int n = 30;  //局部变量
    func1();
    func2(n);
    func3();
    //代码块由{}包围
    {
        int n = 40;  //局部变量
        printf("block n: %d\n", n);
    }
    printf("main n: %d\n", n);
    return 0;
}
 
func1 n: 20
func2 n: 30//main函数内部的 n，而不是外部的 n
func3 n: 10
block n: 40
main n: 30
 
对于 func1()，输出结果为 20，显然使用的是函数内部的 n，而不是外部的 n；func2() 也是相同的情况。
 
当全局变量和局部变量同名时，在局部范围内全局变量被“屏蔽”，不再起作用。或者说，变量的使用遵循就近原则，如果在当前作用域中存在同名变量，就不会向更大的作用域中去寻找变量。
 
 
func3() 输出 10，使用的是全局变量，因为在 func3() 函数中不存在局部变量 n，所以编译器只能到函数外部，也就是全局作用域中去寻找变量 n。
 
 
由{ }包围的代码块也拥有独立的作用域，printf() 使用它自己内部的变量 n，输出 40。
 
 
C语言规定，只能从小的作用域向大的作用域中去寻找变量，而不能反过来，使用更小的作用域中的变量。对于 main() 函数，即使代码块中的 n 离输出语句更近，但它仍然会使用 main() 函数开头定义的 n，所以输出结果是 30。
 
 
全局函数不可以使用成员变量的数据
 
void getValue();

void getValue()
{
	int b = 2;

	cout << a << endl << b << endl;//error：未声明标识符a
}

int main()
{

	int a = 1;

	getValue();

	system("pause");
	return 0;
}
 
A类中使用全局函数
 
A类定义全局函数
B类加入全局函数定义的头文件， 直接使用
 
A类中使用全局变量
 
全局变量在整个源文件——pso.cpp、result.cpp的作用域都是有效的，只需要在一个源文件中定义全局变量
 
//A.h
 extern int a1;
 //A.cpp
 int a1 = 1;

//B.h
#include "pso.h"
//.cpp
qDebug() << a1;
 
example1
 
class1中定义一个全局变量a[20]并赋值，在class2中使用数组a。
 
main.h
 
#include<iostream>
#include <string>
#include<math.h>
#include "class1.h"
#include "class2.h"

using namespace std;
 
int main()
{
	//函数从main文件开始顺序执行
	class1 a1;
	class2 a2;
	
	system("pause");//页面不会消失
	return 0; 
}
 
class1.h文件：
 
#include <iostream>

using namespace std;

extern int a[20];//extern关键字，再次声明这个全局变量

class class1
{
public:
	
	class1();
	~class1();

	//以下为尝试初始化一个static成员变量	
 	//static  int c = 1;//报错：静态成员变量如果初始化，就必须为常量
	//static  const int c = 1;//可以声明，但是必须添加添加const，就无法更改，与cpp函数的功能不符合
	
	static int c;//完成声明和定义，初始化放在了cpp函数中（方法唯一，推荐）
 
    //类似可变的pso
};
 
class1.cpp文件：
 
#include "class1.h"
 
int a[20];//全局变量
 
 //::起到说明作用，告诉编译器是clear1中的c
int class1::c = 1;//类中静态变量的初始化，类似

//全局变量——作用域在所有的cpp
//局部变量——一般是定义在函数的内部

class1::class1()
{
	c = 2;
	
	cout << "class1中数组a的值：";
	for (int i = 0; i < 20; i++) {
		a[i] = i + 1;
		cout << " " << a[i];
	}
	cout << "\n";
}
 
class1::~class1()//析构函数，释放构造函数占用的内存
{
}
 
class2.h文件：
 
#pragma once//仅仅在VS中保证了不会有问题，解决“头文件重定义问题”
#include "class1.h"
 
class class2
{
public:
	class2();
	~class2();
private:

	//自定义的类相当于int类型； int a； int b；都是可以的，因此以下不会报错
	//因为是以类的形式（不是指针，不用分配空间），程序从main文件执行至此处，会运行两次（c1、c2）的class1，因此结果有1+2个数组 
	class1 c1;//类 对象
	class1 c2;
};
 
class2.cpp文件：
 
#include "class2.h"
 
class2::class2()
{
	//cl（class1）作为class2类的成员变量，c作为class类的静态成员变量
	cout << "c1.c的值为：" << c1.c << "     c2.c的值为：" <<c2.c<< endl;
	c1.c = 5; //全局变量的值，可以被改变
	cout << "c1.c的值为：" << c1.c << "     c2.c的值为："<< c2.c << endl;
	cout << "class2中数组a的值：";
	for (int i = 0; i < 20; i++) {
		cout << " " << a[i];
	}
	cout << endl;
}
 
class2::~class2()
{
}
 
结果
 
class1中数组a的值： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
class1中数组a的值： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
class1中数组a的值： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
c1.c的值为：2     c2.c的值为：2
c1.c的值为：5     c2.c的值为：5
class2中数组a的值： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
请按任意键继续. . .
 
static用途
 
定义一个二维数组（不可变的），可变的vector数组不用static const
 
static const int sizepop = 200;//粒子群种群数量.50
static const int psize = 6;// 粒子维数，绕组数量

double p_best[sizepop][psize];//50*18  所有个体最优位置

全局变量往往在Main函数中声明，其作用范围为整个代码；局部变量存在于声明该变量的块语句或方法结束的右花括号({})之前的作用域内。本文对C#中的一些变量声明和范围关系借几个demo展示出来。
 
情况一：变量包含产生歧义
 
根据变量的作用域遵循的原则（局部变量存在于声明该变量的块语句或方法结束的右花括号({})之前的作用域内），第一个变量j是在for循环开始前定义的，它的作用域是Main()方法；第二个变量的作用域是在for循环；第一个变量j的作用域包含了第二个j的作用域。对编译器来说会存在歧义，因为编译器无法区分这两个变量,所以不允许声明第2个 变量。
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20200226bianliang
{
    class Program
    {
        static void Main(string[] args)
        {
            int j = 20;//在Main中定义j为全局变量
            for(int i=0; i<10; i++)
            {
                int j = 30;//在for循环中定义j为局部变量，但两者同为Main中，产生了包含与被包含的关系，顾报错。
                Console.WriteLine(j);
            }
        }
    }
}
 
情况二：变量升级为“类级变量”
 
C#在变量之间有一个基本的区分，类级别声明的变量看作字段（成员变量），而方法中声明的变量看作局部变量。
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20200226bianliang
{
    class Program
    {
        public int j = 20;//在Main外声明了一个类级变量
        static void Main(string[] args)
        {
            int j = 30;//在Main函数中定义了一个Main中的变量
            Console.WriteLine(j);//执行主函数Main，打印Main中的j
            return;
        }
    }
}
 
情况三：主函数中引用类级变量
 
对于情况二，第一个j通过public定义到Main函数之前，“升级”为类级变量（此时属于局部变量），通过下面的这种方法可以实现对类级变量的应用。
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20200226bianliang
{
    class Program
    {
        public int j = 20;
        static void Main(string[] args)
        {
            int j = 30;
            Console.WriteLine(j);
            Program obj = new Program();//new创建对象
            Console.WriteLine("类级变量是:" + obj.j);//调用方法，引用类级变量j
            return;
        }
    }
}
 
情况四 ：static声明引入类级变量
 
如果选择将字段声明为 static，这时调用时可以直接引入类级变量。
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20200226bianliang
{
    class Program
    {
        static int j = 20;//static声明
        static void Main(string[] args)
        {
            int j = 30;
            Console.WriteLine(j);
            //Program obj = new Program();
            Console.WriteLine("类级变量是:" + Program.j);//可直接调用
            return;
        }
    }
}

定义局部变量的基本语法格式同定义成员变量类似，所不同的是不能使用public、protected、private和static关键字对局部变量进行修饰，但可以使用final关键字。
 [final] <变量类型> <变量名>
 final：可选，用于指定该局部变量为常量
 变量类型：必选，用于指定变量的数据类型，其值可以为Java中的任何一种数据类型。
 变量名：必选，用于指定局部变量的名称，变量名必须是合法的Java标识符。
 
public void grow(){
	final boolean STATE;			//声明常量STATE
	int age;								//声明局部变量age
}

全局变量和局部变量的区别在于作用域，全局变量在整个py文件中声明，全局范围内可以使用；局部变量是在某个函数内部声明的，只能在函数内部使用，如果超出使用范围（函数外部），则会报错。
 
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time     :2018/11/28 9:25
# @Author   :yosef
# @Email    :wurz529@foxmail.com
# @File:    :class22.py
# @Software :PyCharm Community Edition
A = 100 # 全局变量一般用大写字母表示

def func():
    a = 50 # 局部变量一般用小写字母表示
    print(a+A)


func()
print(A)
print(a) # 报错信息NameError: name 'a' is not defined
 
 
在函数内部，如果局部变量与全局变量变量名一样，则优先调用局部变量。
 
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time     :2018/11/28 9:55
# @Author   :yosef
# @Email    :wurz529@foxmail.com
# @File:    :class23.py
# @Software :PyCharm Community Edition
A = 100

def func():
    A=250
    print(A)


print(A)    # 打印全部变量
func()      # 局部变量
 
 
如果想在函数内部改变全局变量，需要在前面加上global关键字，在执行函数之后，全局变量值也会改变。
 
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time     :2018/11/28 9:55
# @Author   :yosef
# @Email    :wurz529@foxmail.com
# @File:    :class23.py
# @Software :PyCharm Community Edition
A = 100

def func():
    global  A
    A = 200
    print(A)


print(A)    # 打印全局变量
func()      # 局部变量
print(A)   # 改变后的全局变量
 
 
 
如果全局变量是列表类型，可以通过list的列表方法去对列表进行修改，并且可以不用global来声明。
 
list_1 = [1,2,56,"list"]

def changeList():
    list_1.append("over")
    print(list_1)

changeList()
print(list_1)