在内存中存储结构体类型的变量要占连续一段的存储单元,操作系统实现内存管理的常使用的数据结构为
第0篇编译运行本章例程0.1指针0.2函数指针0.3调用函数指针0.4返回函数指针0.5初始化字符串指针数组0.6主函数的参数0.7处理单个文件读写0.8处理多个文件读写0.9自动管内存0.10为对象分配和释放内存0.11为数组分配和释放空指针0.12为数组分配和释放内存1重写学生成绩程序， 要求生成字母成就2重写中值函数，使其可以通过向量或C自带数组调用函数。 该函数要求您可以调用保存任何算术类型的容器。3需要编写一个mdian函数，它不会改变容器中元素的顺序4。写一个可以存储字符串链表的类(也就是写一个vector\) 5。为上面的String_list类写一个双向迭代器(不带尾指针)6。重写split函数并将结果输出到String_list类。
0编译并运行本章程序。
0.1指针//指针
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
int main(int argc，char** argv){
int x=5；
int * p=x；//指向x地址的指针
cout x= x endl
* p=6；
cout x= x endl
返回0；
}
0.2函数指针//函数指针
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
int next(int n){
返回n ^ 1；
}
int main(int argc，char** argv){
int(* FP)(int)；
fp=next//将fp指向下一个函数
//FP=next；
int I=(* FP)(6)；
//int I=FP(6)；
cout i endl
返回0；
}
0.3调用函数的指针//返回函数的指针
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:ostream；
int test1(int a){
返回1；
}
int test2(int b){
返回B3；
}
void write(ostream out，int test(int)，int a){
out test(a)endl；
}
void write2(ostream out，int (*test)(int)，int a){
out test(a)endl；
}
int main(int argc，char** argv){
int x=10
write(cout，test1，x)；
write(cout，test2，x)；
write2(cout，test1，x)；
write2(cout，test2，x)；
返回0；
}
0.4返回指向函数的指针//返回指向函数的指针
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:ostream；
int test1(int a){
a；
返回a；
}
//声明
typedef int(* test _ FP)(int)；
test _ FP test3(int)；
//定义
test_fp test3(int x){
int(* FP)(int)=test1；
(* FP)(x)；//x的值变成11
返回FP；
}
//声明
int(* test 4(int))(int)；
//定义
int (*test4(int x))(int ){
int(* FP)(int)=test1；
(* FP)(x)；//x的值变成11
返回FP；
}
void write2(ostream out，int test(int)，int a){
out test(a)endl；
}
int main(int argc，char** argv){
int x=10
//当//测试通过时，引用会导致x的变化，当write通过时，没有引用，计算完值后丢弃。
//10加2
//第一次调用test时加1。因为是引用，所以X实际上会变成11。第二次调用write时加1。虽然结果是12，但是X的值仍然是11。
write2(cout，test3(x)，x)；
write2(cout，test4(x)，x)；//11加2
返回0；
}
0.5初始化字符串指针数组//初始化字符串指针数组
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:string；
字符串字母_等级(双等级){
静态常数double numbers[]={
97, 94, 90, 87, 84, 80, 77, 74, 70, 60, 0
};
静态常量char*常量字母[]={
A ， A ， B ， B ， C ， C-， D ， F
};
static const size _ t n grades=sizeof(数字)/sizeof(*数字)；//计算这个元素的数目
for(size _ t I=0；i ngradesi) {
if(grade=numbers[i]){
回信[I]；
}
}
返回？\?\?；//C不允许两个或多个连续的问号。
}
int main(int argc，char** argv){
const char hello[]={H ， e ， l ， l ， \ 0 }；
static char hello3[]={H ， e ， l ， l ， o }；//初始化时，自动在末尾加上 \0 。
string hello2= Hello
//测试1
//if(hello3==hello2){
//cout“Yes”；
//}其他{
//cout“No”；
//}
//测试2
//cout strlen(hello)endl；//不包括末尾的\0
//测试三
//string s(hello，hello strlen(hello))；
//cout s
//测试四
cout letter _ grade(88)endl；
返回0;
}
0.6主函数的参数//勉函数的参数
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
int main(int argc，char** argv){
if(argc 1){
cout argv[1]；
for(int I=2；我！=argci) {
cout argv[I]；
}
}
cout结束
cout argc endl
返回0;
}
0.7 处理单个文件读写//处理文件的读写
#包括
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:if流；
使用STD:of stream；
使用STD:string；
int main(int argc，char** argv){
string file=/Users/macbook pro/clion projects/ACM/infile。txt ；
ifstream infile(文件。c _ str())；
//ifstream infile(/Users/macbook pro/clion projects/ACM/infile。txt’)；//等价于上面的两行
的流输出文件(/Users/macbook pro/clion projects/ACM/outfile。txt’)；
字符串s；
while(getline(infile，s)){
输出文件结尾
}
返回0;
}
0.8 处理多个文件的读写//多个文件读入
#包括
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:if流；
使用STD:of stream；
使用STD:string；
使用STD:cerr；
int main(int argc，char** argv){
int fail _ count=0；
for(int I=1；i argci) {
if stream in(argv[I])；
如果（在){
字符串s；
while(getline(in，s)){
cout s endl
}
}否则{
" cerr "无法打开文件“argv[I]endl；
失败计数；
}
返回失败计数
}
返回0;
}
/*
/用户/macbook pro/clion projects/ACM/infile 2。txt/用户/macbook pro/clion projects/ACM/infile。文本文件（textfile）
*/
0.9 自动管理内存//自动管理内存
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
//故意产生一个无效指针
int* invalid_pointer(){//c并不会发现错误
int x；
返回x；//紧急灾难
}
int* pointer_to_static(){
静态int x；
返回x；
}
int main(int argc，char** argv){
cout invalid _ pointer()endl；
标准输出指针_指向_静态();
返回0;
}
0.10 为对象分配释放内存//为对象分配释放内存
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
int main(int argc，char** argv){
int * p=new int(42)；
* p；
删除p；
cout * p；//指针p依然存在，且指向的地址不变。
返回0;
}
0.11 为数组分配和释放空指针//为数组分配和释放指针
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
使用STD:vector；
int main(int argc，char** argv){
int n=0；
int * p=new int[n]；//会返回一个有效但无意义的在终点之外指针
//可以想象成一个指向（如果存在的话)首元素的指针
向量int v(p，p n)；
删除[]p；
返回0;
}
0.12 为数组分配释放内存//为数组分配释放内存
#包括
#包括
#包括
使用STD:cout；
使用STD:CIN；
使用STD:endl；
size_t strlen(const char* p){
size _ t size=0；
while(*p！=\0){
尺寸；
}
返回大小；
}
模板类输入，类输出
输出副本（输入开始，输入结束，输出目标){
而(开始！=end){
*目标=*开始
}
返回目的地；
}
char* duplicate(const char* p){
size _ t length=strlen(p)1；//为空字符预留空间\0
char * result=new char[length]；
复制(p，p长度，结果);
返回结果；
}
int main(int argc，char** argv){
char str[]={i ， l ， o ， v ， e }；
STD:string s=duplicate(str)；
cout s；
返回0;
}
一重写学生成绩程序，要求生成字母成绩头文件
//
//grade.h
//
#ifndef ACM_GRADE_H
#定义ACM等级H
#包括
#包含"学生信息"
双等级（双、双、双);
double grade(double，double，const STD:vector double)；
//双等级(const学生信息
#endif//
//tudent_info.h
//
#ifndef ACM_Student_info
#定义ACM _学生信息
#包括
#包括
#包括
//结构学生信息{
//std:字符串名称；
//双期中，期末；
//std:矢量作业；
//
//STD:istream read(STD:istream
//double garde()const；
//};
班级学生信息{
公共：
学生信息();//构造一个空的学生信息对象
student _ info(STD:istream)；//读一个流从而构造一个对象
bool vaild() const{ return！工作。empty()；}//检查对象是否为空
双等级()常数
STD:istream read(STD:istream)；
STD:string name()const { return n；}//存取器：容许对一部分数据结构的进行访问
私人：
STD:string n；
双期中考，期末考；
标准：向量双作业；
};
bool compare(const Student_info，const Student _ info)；
STD:istream read _ HW(STD:istream，STD:vector double)；
//STD:istream read(STD:istream，Student_info
#endif#include
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#include Student_info.h
#包含" h级"
使用STD:CIN；使用STD:cout；
使用STD:endl；
使用STD:istream；
使用STD:vector；
使用STD:string；
使用STD:max；
使用STD:sort；
使用STD:domain _ error；
使用STD:设置精度；
使用STD:streamsize；
//默认构造函数
学生信息：学生信息():期中(0),期末(0){ }
//带参构造函数
Student _ info:Student _ info(istream is){ read(is)；}
布尔比较（常量学生信息x，常量学生信息y){
返回x . name()y . name()；
}
istream Student _ info:read(istream in){
期中期末考试；
读取硬件(在，作业);
返回；
}
istream read_hw(istream in，vector double hw){
如果（在){
硬件。clear()；
双x；
而(在x中){
硬件。push _ back(x)；
}
英寸clear()；
}
返回；
}
双中值（向量双向量){
typedef vector double:size _ type vec _ SZ；
vec _ SZ size=vec。size()；
if(size==0){
抛出domain_error(空向量的中值);
}
sort(vec.begin()、vec。end())；
vec _ SZ mid=size/2；
返回大小% 2==0?(vec[mid]vec[mid-1])/2:vec[mid]；
}
double Student _ info:grade()const {
//:使用这个名称的某一个版本，而所使用的这个版本不能称为任何事物的成员
返回：成绩（期中、期末、作业);
}
双倍分数（双倍期中，双倍期末，常数向量双倍硬件){
if(hw.size()==0)
抛出domain_error(学生没有做作业);
回报等级（期中、期末、中位数(HW))；//如果家庭作业非空，则调用三年级
}//2级
双倍分数（期中双倍，期末双倍，硬件双倍){
返回期中* 0.2期末* 0.4硬件* 0.4
}
字符串字母_等级(双等级){//新增
//分数成绩的界限
静态常数双数[]={
97, 94, 90, 87, 84, 80, 77, 74, 70, 60, 0
};
//字母成绩表示
静态常量字符*常量字母[]={
A ， A ， A-， B ， B-， C ， C-， D ， F
};
//根据数组的大小计算成绩的个数
//和单个元素的大小
静态常数size _ t n grades=sizeof(数字)/sizeof(*数字);
for(size _ t I=0；i ngradesi) {
if(grade=numbers[i]){
回函[I]；
}
}
返回？\?\?
}
int main(int argc，char const *argv[]){
矢量学生信息学生；
学生信息记录；
string:size _ type maxlen=0；
while(record.read(cin)){//
maxlen=max(maxlen，record.name().size())；//
学生。推回(记录);
}
排序(students.begin()、students.end()、compare)；
for(vector Student _ info:size _ type I=0；我！=学生。size()；i) {
标准输出学生[我].name()//
字符串(maxlen 1 -学生[我].名称()。size()， )；
//尝试{
//double final _ grade=students[I].年级();
//streamsize prec=cout。精度()；
//cout setprecision(3)final _ grade
//设置精度(prec)endl；
//}catch(domain_error e){
//cout e . what()endl；
//}
如果（学生[我]。vaild()==true){
双期末_成绩=学生[我].年级();
//streamsize prec=cout。精度()；
//cout setprecision(3)final _ grade
//设置精度(prec)endl；
标准输出字母_ grade(final _ grade)endl；//新增
}否则{
cout 作业是空的!恩德尔
}
}
返回0;
}2 重写中位数函数，使之可以通过向量或C自带的数组以调用该函数。该函数要求可以调用容纳任何算数类型的容器。//求中位数
#包括
#包括
#包括
#包括
#包括
使用STD:CIN；使用STD:cout；
使用STD:endl；
使用STD:vector；
使用STD:domain _ error；
使用STD:sort；
使用STD:ostream；
中的模板类
在中间（在开始，在结束){
size_t size=std:distance(begin，end)；
if(size==0){
抛出domain_error(空向量的中值);
}
排序（开始，结束);
size _ t mid=size/2；
在ans=开始中期；//偶数个
if(size % 2==0){//奇数个
* ans=(*(begin mid)*(begin mid-1))/2；
//* ans=(begin[mid]begin[mid-1])/2；//与上面等价
}
返回美国国家标准（American National Standards的缩写）
}
int main(int argc，char const *argv[])
{
向量双v={ 85，74，75，45，49，67 }；
cout *median(v.begin()、v . end())endl；
返回0;
}3 要求写一个不会改变容器内元素顺序的中位数函数//求中位数
#包括
#包括
#包括
#包括
#包括
使用STD:CIN；使用STD:cout；
使用STD:endl；
使用STD:vector；
使用STD:domain _ error；
使用STD:sort；
使用STD:ostream；
中的模板类，类T
t中值（开始时，结束时){
size_t size=std:distance(begin，end)；
if(size==0){
抛出domain_error(空向量的中值);
}
//把容器内的元素复制到向量中，进行排序计算，以免影响原序列
STD:vector T v；
而(开始！=end){
五。push _ back(* begin)；
}
std:sort(v.begin()、v . end())；
size _ t mid=size/2；
返回大小% 2==0?(v[mid]v[mid-1])/2:v[mid]；
}
int main(int argc，char const *argv[])
{
向量双v={ 85，74，75，45，49，67 }；
double v2[]={85，74，75，45，49，67 }；
标准输出中值向量double :iterator，double (v.begin()、v . end())endl；
for(vector double:const _ iterator it=v . begin()；它！=v . end()；它){
cout * it
}
cout结束
cout median double*，double (v2，v2(sizeof(v2)/sizeof(* v2)))endl；
for(int I=0；I(sizeof(v2)/sizeof(* v2))；i) {
cout v2[I]”；
}
返回0;
}4 写一个类可以存储用线串的链表（也就是写一个向量)头文件
#ifndef TEST_H
#定义测试_H
#包括
类字符串列表{
公共：
typedef std:string*迭代器；
typedef const STD:string * const _ iterator；
//构造函数
string _ list():l(new STD:string[1])，size(0)，max(1){
f=l最大值
}
//复制构造函数
String _ list(const String _ list s){ create(s . begin()、s . end())；}
//赋值运算符函数
字符串列表运算符=(const String_list rhs){
如果(rhs！=这个){
un create()；
create(rhs.begin()、rhs。end())；
}
返回*这个
}
//析构函数
~ String _ list(){ un create()；};
void push _ back(STD:string)；
STD:string * begin(){ return l；}
const STD:string * begin()const { return l；}
STD:string * end(){ return f；}
const STD:string * end()const { return f；}
私人：
STD:string * l；//指针指向第一个元素
STD:string:size _ type size；//拥有有效数值的最大长度
STD:string:size _ type max；//分配空间的最大长度
STD:string * f；//指针指向存储元素的最后一个后面的指针
void grow()；
void create(const std:string*，const STD:string *)；
void uncreate(){
删除[](l)；
l=f=0；
size=max=0；
}
};
#endif主函数
#包括
使用STD:CIN；使用STD:cout；
使用STD:endl；
#包括
使用STD:string；
#包含" test.h "
#包括
使用STD:find _ if；
void String _ list:create(const _ iterator begin，const_iterator end){
size=max=end-begin；
l=新字符串[大小];
迭代器temp=l；
而(开始！=end){
*温度=*开始
}
f=l尺寸；
}
//推送_返回函数的成员函数
void String_list:grow() {
//扩展对象大小时，为对象分配实际使用的两倍大小的内存空间
max *=2；
迭代器new_l=新字符串[max]；
//分配新的内存空间并将已存在的对象元素内容复制搭配新内存中
for(string:size _ type I=0；我！=大小；i) {
new _ l[I]=l[I]；
}
//删除原来的内存空间
删除[](l)；
//重置指针，使其指向新分配的内存空间
l=新_ l
f=最大新长度
}
void String _ list:push _ back(STD:String str){
if(size==max){
grow()；
}
l[size]=str；
}
bool not_space(char c){
回归！是空间(c)；
}
布尔空格（字符c){
返回是空间(c)；
}
string _ list split(const string str){
typedef string:const _ iterator ITER；
字符串列表返回
ITER一世=str。begin()；
而（我！=str.end()){
i=find_if(i，str.end()，not _ space)；
iter j=find_if(i，str.end()，space)；
如果（我！=str.end()){
ret.push_back(string(i，j))；
}
I=j；
}
返回浸水使柔软
}
int main(int argc，char ** argv){
字符串_列表s；
//复制构造函数
s。push _ back( I )；
s.push_back(爱);
s.push_back(你);
s.push_back(！);
//复制构造函数
string _ list S2=s；
迭代程序ITER=S2。begin()；
while (iter！=s2.end())
cout * iter endl
//测双向迭代器
while(iter！=s2.begin()){
cout *(ITER)endl；
}
//测赋值运算符
//String _ list S3；
//S3。push _ back( I )；
//s3.push_back(恨);
//S3。push _ back( U )；
//S2=S3；
//for(String _ list:iterator it=S2。begin()；它！=S2。end()；它){
//cout * it " "；
//}
//测使分离函数
//字符串s；
//while(cin)
//String _ list RES=split(s)；
//for(string * it=RES . begin()；它！=RES . end()；它){
//cout * it endl；
//}
//}
返回0;
}5 为上面的字符串列表类写一个双向迭代器（不用尾指针)#ifndef TEST_H
#定义测试_H
#包括
类字符串列表{
公共：
typedef std:string*迭代器；
typedef const STD:string * const _ iterator；
//构造函数
string _ list():l(new STD:string[1])，size(0)，max(1){}
//复制构造函数
String _ list(const String _ list s){ create(s . begin()、s . end())；}
//赋值运算符函数
字符串列表运算符=(const String_list rhs){
如果(rhs！=这个){
un create()；
create(rhs.begin()、rhs。end())；
}
返回*这个
}
//析构函数
~ String _ list(){ un create()；};
void push _ back(STD:string)；
STD:string * begin(){ return l；}
const STD:string * begin()const { return l；}
STD:string * end(){ return l size；}
const STD:string * end()const { return l size；}
私人：
STD:string * l；//指针指向第一个元素
STD:string:size _ type size；//有有效数值的最大长度
STD:string:size _ type max；//分配空间的最大长度
void grow()；
void create(const std:string*，const STD:string *)；
void uncreate(){
删除[](l)；
l=0；
size=max=0；
}
};
#endif#include
使用STD:CIN；使用STD:cout；
使用STD:endl；
#包括
使用STD:string；
#包含" test.h "
#包括
使用STD:find _ if；
void String _ list:create(const _ iterator begin，const_iterator end){
size=max=end-begin；
l=新字符串[大小];
迭代器temp=l；
而(开始！=end){
*温度=*开始
}
}
//推送_返回函数的成员函数
void String_list:grow() {
//扩展对象大小时，为对象分配实际使用的两倍大小的内存空间
max *=2；
迭代器new_l=新字符串[max]；
//分配新的内存空间并将已存在的对象元素内容复制搭配新内存中
for(string:size _ type I=0；我！=大小；i) {
new _ l[I]=l[I]；
}
//删除原来的内存空间
删除[](l)；
//重置指针，使其指向新分配的内存空间
l=新_ l
}
void String _ list:push _ back(STD:String str){
if(size==max){
grow()；
}
l[size]=str；
}
bool not_space(char c){
回归！是空间(c)；
}
布尔空格（字符c){
返回是空间(c)；
}
string _ list split(const string str){
typedef string:const _ iterator ITER；
字符串列表返回
ITER一世=str。begin()；
而（我！=str.end()){
i=find_if(i，str.end()，not _ space)；
iter j=find_if(i，str.end()，space)；
如果（我！=str.end()){
ret.push_back(string(i，j))；
}
I=j；
}
返回浸水使柔软
}
int main(int argc，char ** argv){
字符串_列表s；
//复制构造函数
s。push _ back( I )；
s.push_back(爱);
s.push_back(你);
s.push_back(！);
//
//复制构造函数
string _ list S2=s；
迭代程序ITER=S2。begin()；
while (iter！=s2.end())
cout * iter endl
//测双向迭代器
while(iter！=s2.begin()){
cout *(ITER)endl；
}
//
//
////测赋值运算符
//String _ list S3；
//S3。push _ back( I )；
//s3.push_back(恨);
//S3。push _ back( U )；
//
//S2=S3；
//for(String _ list:iterator it=S2。begin()；它！=S2。end()；它){
//cout * it " "；
//}
//测使分离函数
//字符串s；
//while(cin)
//String _ list RES=split(s)；
//for(string * it=RES . begin()；它！=RES . end()；它){
//cout * it endl；
//}
//}
返回0;
}6 重写使分离函数将结果输出到字符串列表类中。ifndef测试_H
#定义测试_H
#包括
类字符串列表{
公共：
typedef std:string*迭代器；
typedef const STD:string * const _ iterator；
//构造函数
string _ list():l(new STD:string[1])，size(0)，max(1){}
//复制构造函数
String _ list(const String _ list s){ create(s . begin()、s . end())；}
//赋值运算符函数
字符串列表运算符=(const String_list rhs){
如果(rhs！=这个){
un create()；
create(rhs.begin()、rhs。end())；
}
返回*这个
}
//析构函数
~ String _ list(){ un create()；};
void push _ back(STD:string)；
STD:string * begin(){ return l；}
const STD:string * begin()const { return l；}
STD:string * end(){ return l size；}
const STD:string * end()const { return l size；}
私人：
STD:string * l；//指针指向第一个元素
STD:string:size _ type size；//有有效数值的最大长度
STD:string:size _ type max；//分配空间的最大长度
void grow()；
void create(const std:string*，const STD:string *)；
void uncreate(){
删除[](l)；
l=0；
size=max=0；
}
};
#endif#include
使用STD:CIN；使用STD:cout；
使用STD:endl；
#包括
使用STD:string；
#包含" test.h "
#包括
使用STD:find _ if；
void String _ list:create(const _ iterator begin，const_iterator end){
size=max=end-begin；
l=新字符串[大小];
迭代器temp=l；
而(开始！=end){
*温度=*开始
}
}
//推送_返回函数的成员函数
void String_list:grow() {
//扩展对象大小时，为对象分配实际使用的两倍大小的内存空间
max *=2；
迭代器new_l=新字符串[max]；
//分配新的内存空间并将已存在的对象元素内容复制搭配新内存中
for(string:size _ type I=0；我！=大小；i) {
new _ l[I]=l[I]；
}
//删除原来的内存空间
删除[](l)；
//重置指针，使其指向新分配的内存空间
l=新_ l
}
void String _ list:push _ back(STD:String str){
if(size==max){
grow()；
}
l[size]=str；
}
bool not_space(char c){
回归！是空间(c)；
}
布尔空格（字符c){
返回是空间(c)；
}
string _ list split(const string str){
typedef string:const _ iterator ITER；
字符串列表返回
ITER一世=str。begin()；
而（我！=str.end()){
i=find_if(i，str.end()，not _ space)；
iter j=find_if(i，str.end()，space)；
如果（我！=str.end()){
ret.push_back(string(i，j))；
}
I=j；
}
返回浸水使柔软
}
int main(int argc，char ** argv){
//String _ list s；
////复制构造函数
//s . push _ back( I )；
//s . push _ back( love )；
//s . push _ back( you )；
//s.push_back(！);
////复制构造函数
//String _ list S2=s；
//
//String _ list:迭代器ITER=S2。begin()；
//while (iter！=s2.end())
//cout * ITER endl；
////测双向迭代器
//while(iter！=s2.begin()){
//cout *(ITER)
//}
////测赋值运算符
//String _ list S3；
//S3。push _ back( I )；
//s3.push_back(恨);
//S3。push _ back( U )；
//
//S2=S3；
//for(String _ list:iterator it=S2。begin()；它！=S2。end()；它){
//cout * it " "；
//}
//测使分离函数
字符串s；
(CIN ){
string _ list RES=split(s)；
for(string * it=RES . begin()；它！=RES . end()；它){
cout * it结束
}
}
返回0;
}
来自51C
TO博客作者fanxinglanyu的原创作品，
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。