C++Qt中，的 局部变量、全局变量的声明、定义和初始化_qt 局部变量

局部变量

定义

定义在函数内部的变量称为局部变量（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;
}
1
2
3
4
5
6
7
8
9
10

1. main 函数中定义的变量也是局部变量，只能在 main 函数中使用；同时，main 函数中也不能使用其它函数中定义的变量。main 函数也是一个函数，与其它函数地位平等。
   如果要使用，可以通过指针，B类成为main类的成员函数

2. 形参变量、在函数体内定义的变量都是局部变量。实参给形参传值的过程也就是给局部变量赋值的过程。

3. 可以在不同的函数中使用相同的变量名，它们表示不同的数据，分配不同的内存，互不干扰，也不会发生混淆。

4. 在语句块中也可定义变量，它的作用域只限于当前语句块

全局变量

定义

在所有函数外部定义的变量称为全局变量（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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

func1 n: 20
func2 n: 30//main函数内部的 n，而不是外部的 n
func3 n: 10
block n: 40
main n: 30
1
2
3
4
5

1. 对于 func1()，输出结果为 20，显然使用的是函数内部的 n，而不是外部的 n；func2() 也是相同的情况。

当全局变量和局部变量同名时，在局部范围内全局变量被“屏蔽”，不再起作用。或者说，变量的使用遵循就近原则，如果在当前作用域中存在同名变量，就不会向更大的作用域中去寻找变量。

2. func3() 输出 10，使用的是全局变量，因为在 func3() 函数中不存在局部变量 n，所以编译器只能到函数外部，也就是全局作用域中去寻找变量 n。

3. 由{ }包围的代码块也拥有独立的作用域，printf() 使用它自己内部的变量 n，输出 40。

4. 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

A类中使用全局函数

1. A类定义全局函数
2. B类加入全局函数定义的头文件， 直接使用

A类中使用全局变量

全局变量在整个源文件——pso.cpp、result.cpp的作用域都是有效的，只需要在一个源文件中定义全局变量

//A.h
 extern int a1;
 //A.cpp
 int a1 = 1;

//B.h
#include "pso.h"
//.cpp
qDebug() << a1;
1
2
3
4
5
6
7
8
9

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; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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()//析构函数，释放构造函数占用的内存
{
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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()
{
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

结果

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
请按任意键继续. . .
1
2
3
4
5
6
7

static用途

定义一个二维数组（不可变的），可变的vector数组不用static const

static const int sizepop = 200;//粒子群种群数量.50
static const int psize = 6;// 粒子维数，绕组数量

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