简单说结构体，就是一个可以包含不同类型的数据结构，他是一种可以自己定义的数据类型。他和数组的主要区别——结构体可以在结构中声明不同的数据类型，相同的结构体可以互相赋值，而数组是做不到的，因为数组是单一数据类型的数据集合，它本身不是数据类型(而结构体是)，数组名称是常量指针，所以不可以做为左值进行运算，所以数组之间就不能通过数组名称相互复制了，即使数据类型和数组大小完全相同。
简单的结构体定义：
struct test
{
float a;
int b;
};
由于结构体本身就是自定义的数据类型，定义结构体变量的方法和定义普通变量的方法一样——test pn1;
这样就定义了一test结构体数据类型的结构体变量pn1，结构体成员的访问通过点操作符进行，pn1.a=10 就对结构体变量pn1的成员a进行了赋值操作。
注意:结构体生命的时候本身不占用任何内存空间，只有当你用你定义的结构体类型定义结构体变量的时候计算机才会分配内存
结构体，同样是可以定义指针的，那么结构体指针就叫做结构指针。
结构指针通过->符号来访问成员，下面我们就以上所说的看一个完整的例子：
#include <iostream>
#include <string>
using namespace std;
struct test//定义一个名为test的结构体
{
int a;//定义结构体成员a
int b;//定义结构体成员b
};
void main()
{
test pn1;//定义结构体变量pn1
test pn2;//定义结构体变量pn2
pn2.a=10;//通过成员操作符.给结构体变量pn2中的成员a赋值
pn2.b=3;//通过成员操作符.给结构体变量pn2中的成员b赋值
pn1=pn2;//把pn2中所有的成员值复制给具有相同结构的结构体变量pn1
cout<<pn1.a<<"|"<<pn1.b<<endl;
cout<<pn2.a<<"|"<<pn2.b<<endl;
test *point;//定义结构指针
point=&pn2;//指针指向结构体变量pn2的内存地址
cout<<pn2.a<<"|"<<pn2.b<<endl;
point->a=99;//通过结构指针修改结构体变量pn2成员a的值
cout<<pn2.a<<"|"<<pn2.b<<endl;
cout<<point->a<<"|"<<point->b<<endl;
cin.get();
}
总之，结构体可以描述数组不能够清晰描述的结构，它具有数组所不具备的一些功能特性。
下面我们来看一下，结构体变量是如何作为函数参数进行传递的。
struct test
{
char name[10];
float socre;
};
void print_score(test pn)//以结构变量进行传递
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
void print_score(test *pn)//一结构指针作为形参
{
cout<<pn->name<<"|"<<pn->socre<<endl;
}
void main()
{
test a[2]={{"marry",88.5},{"jarck",98.5}};
int num = sizeof(a)/sizeof(test);
for(int i=0;i<num;i++)
{
print_score(a[i]);
}
for(int i=0;i<num;i++)
{
print_score(&a[i]);
}
cin.get();
}
void print_score(test *pn)的效率是要高过void print_score(test pn)的，因为直接内存操作避免了栈空间开辟结构变量空间需求，节省内存。
结构体引用传递
利用引用传递的好处很多，它的效率和指针相差无几，但引用的操作方式和值传递几乎一样，种种优势都说明善用引用可以做到程序的易读和易操作，它的优势尤其在结构和大的时候，避免传递结构变量很大的值，节省内存，提高效率
#include <iostream>
#include <string>
using namespace std;
struct test
{
char name[10];
float socre;
};
void print_score(test &pn)//以结构变量进行传递
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
void main()
{
test a[2]={{"marry",88.5},{"jarck",98.5}};
int num = sizeof(a)/sizeof(test);
for(int i=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
上面我们说明了易用引用对结构体进行操作的优势，下面我们重点对比两个例程，进一部分析关于效率的问题。
//-------------------------------------例程1---------------------------------
#include <iostream>
#include <string>
using namespace std;
struct test
{
char name[10];
float socre;
};
void print_score(test &pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
test get_score()
{
test pn;
cin>>pn.name>>pn.socre;
return pn;
}
void main()
{
test a[2];
int num = sizeof(a)/sizeof(test);
for(int i=0;i<num;i++)
{
a[i]=get_score();
}
cin.get();
for(int i=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
//-------------------------------------例程2---------------------------------
#include <iostream>
#include <string>
using namespace std;
struct test
{
char name[10];
float socre;
};
void print_score(test &pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
void get_score(test &pn)
{
cin>>pn.name>>pn.socre;
}
void main()
{
test a[2];
int num = sizeof(a)/sizeof(test);
for(int i=0;i<num;i++)
{
get_score(a[i]);
}
cin.get();
for(int i=0;i<num;i++)
{
print_score(a[i]);
}
cin.get();
}
例程2的效率要远高过例程1的原因主要有以下两处：
第一:
例程1中的
test get_score()
{
test pn;
cin>>pn.name>>pn.socre;
return pn;
}
调用的时候在内部要在栈空间开辟一个名为pn的结构体变量，程序pn的时候又再次在栈内存空间内自动生成了一个临时结构体变量temp，在前面的教程中我们已经说过，它是一个copy，而例程2中的：
void get_score(test &pn)
{
cin>>pn.name>>pn.socre;
}
却没有这一过程，不开辟任何新的内存空间，也没有任何临时变量的生成。
第二:
例程1在mian()中，必须对返回的结构体变量进行一次结构体变量与结构体变量直接的相互赋值操作。
for(int i=0;i<num;i++)
{
a[i]=get_score();
}
而例程2中由于是通过内存地址直接操作，所以完全没有这一过程，提高了效率。
for(int i=0;i<num;i++)
{
get_score(a[i]);
}
函数也是可以返回结构体引用的，例子如下：
#include <iostream>
#include <string>
using namespace std;
struct test
{
char name[10];
float socre;
};
test a;
test &get_score(test &pn)
{
cin>>pn.name>>pn.socre;
return pn;
}
void print_score(test &pn)
{
cout<<pn.name<<"|"<<pn.socre<<endl;
}
void main()
{
test &sp=get_score(a);
cin.get();
cout<<sp.name<<"|"<<sp.socre;
cin.get();
}
调用get_score(a);结束并返回的时候，函数内部没有临时变量的产生，返回直接把全局结构变量a的内存地址赋予结构引用sp
最后提一下指针的引用
定义指针的引用方法如下：
void main()
{
int a=0;
int b=10;
int *p1=&a;
int *p2=&b;
int *&pn=p1;
cout <<pn<<"|"<<*pn<<endl;
pn=p2;
cout <<pn<<"|"<<*pn<<endl;
cin.get();
}
pn就是一个指向指针的引用，它也可以看做是指针别名，总之使用引用要特别注意它的特性，它的操作是和普通指针一样的，在函数中对全局指针的引用操作要十分小心，避免破坏全局指针！
在这里对C++的引用做一下说明：
引用是C++中的概念，初学者容易把引用和指针混淆一起。一下程序中，n是m的一个引用（reference），m是被引用物（referent）。
int m;
int &n = m;
n相当于m的别名（绰号），对n的任何操作就是对m的操作。例如有人名叫王小毛，他的绰号是“三毛”。说“三毛”怎么怎么的，其实 就是对王小毛说三道四。所以n既不是m的拷贝，也不是指向m的指针，其实n就是m它自己。
引用的一些规则如下：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化,最好也在创建时被初始化。）。
（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
例如下例的当改变k时，I的值也随之改变，这就证明不能改变其关系。
以下示例程序中，k被初始化为i的引用。语句k = j并不能将k修改成为j的引用，只是把k的值改变成为6。由于k是i的引用，所以i的值也变成了6。
int i = 5;
int j = 6;
int &k = i;
k = j; // k和i的值都变成了6;
上面的程序看起来象在玩文字游戏，没有体现出引用的价值。引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。
以下是“值传递”的示例程序。由于Func1函数体内的x是外部变量n的一份拷贝，改变x的值不会影响n, 所以n的值仍然是0。
void Func1(int x)
{
x = x + 10;
}
…
int n = 0;
Func1(n);
cout << “n = ” << n << endl; // n = 0
以下是“指针传递”的示例程序。由于Func2函数体内的x是指向外部变量n的指针，改变该指针的内容将导致n的值改变，所以n的值成为10。
void Func2(int *x)
{
(* x) = (* x) + 10;
}
…
int n = 0;
Func2(&n);
cout << “n = ” << n << endl; // n = 10
以下是“引用传递”的示例程序。由于Func3函数体内的x是外部变量n的引用，x和n是同一个东西，改变x等于改变n，所以n的值成为10。
void Func3(int &x)
{
x = x + 10;
}
…
int n = 0;
Func3(n);
cout << “n = ” << n << endl; // n = 10
对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”这东西？
答案是“用适当的工具做恰如其分的工作”。
指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。就象一把刀，它可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？
如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
