国际物流网站建设,电脑怎么做最新系统下载网站,中国建设银行北京天竺支行网站,wordpress thems函数参数的传递机制
C的每个程序至少有一个函数#xff0c;即主函数main()#xff0c;函数也是类的方法的实现手段。C的函数包括两类#xff1a;预定于函数和用户自定义函数。
函数的定义格式为#xff1a;
返回值类型函数名(参数列表)
函…函数参数的传递机制
C的每个程序至少有一个函数即主函数main()函数也是类的方法的实现手段。C的函数包括两类预定于函数和用户自定义函数。
函数的定义格式为
返回值类型函数名(参数列表)
函数体
其中返回值类型实值函数返回值的数据类型可以是任意一种基本数据类型或用户自定义数据类型以及类类型。函数名是给函数指定的名字函数名应遵循标识符的命名规定。参数列表是指参数的个数、名称和类型函数定义中的参数成为形参。函数体实值函数完成的功能由说明语句和执行语句组成。
在C语言中函数的参数传递有三种方式按变量值传递、按变量的地址传递和引用传递。C语言可以用简单变量作为参数进行传递也可以将对象作为参数传递给函数其方法与传递其他类型的数据一样。
使用对象作为函数参数
对象作为函数参数时其参数传递机制与其他类型的数据作为函数参数相同。在进行函数调用时可将实参对象的值复制一份给对应的形参对象。因此作为形参的对象其数据的改变并不会影响实参对象。
实例
#include iostream
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point p){p.x p.x 1;p.y p.y 1;}void Print(){cout x: x , y: y endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout before move:;p1.Print();p1.Move(p1);cout after move:;p1.Print();return 0;
}运行结果
before move:x:1, y:2
after move:x:1, y:2使用对象指针作为函数参数
在进行函数调用时以对象指针作为参数其实质是传地址调用即参数与实参共享同一内存单元。因此作为形参的对象其数据的改变将影响实参对象从而实现函数之间的信息传递。此外使用对象指针作为参数仅将对象的地址传递给形参而不进行副本的复制可以提高运行效率减少时空开销。
实例
#include iostream
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point *p){(*p).x (*p).x 1;//也可以写成p-xp-x 1(*p).y (*p).y 1;}void Print(){cout x: x , y: y endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout before move:;p1.Print();p1.Move(p1);cout after move:;p1.Print();return 0;
}运行结果
before move:x:1, y:2
after move:x:1, y:2使用对象引用作为函数参数
用对象引用作为函数参数不但具有用对象指针作为函数参数的优点而且相比之下用对象引用作为函数参数可更简单、更直接。
实例
#include iostream
using namespace std;
class Point{
public:Point(int a, int b):x(a),y(b){}void Move(Point p){p.x p.x 1;p.y p.y 1;}void Print(){cout x: x , y: y endl;}
private:int x, y;
};int main(){Point p1(1, 2);cout before move:;p1.Print();p1.Move(p1);cout after move:;p1.Print();return 0;
}运行结果
before move:x:1, y:2
after move:x:1, y:2三种传递方式比较
适用对象作为函数参数。当进行函数调用时需要给形参分配存储单元形参和实参的结合是值传递实参将自己的值传递给形参形参实际上是实参的副本。这是一种单向传递形参的变化不会影响到实参。使用指针作为函数参数。当进行函数调用时需要给形参分配存储单元形参和实参的结合是地址传递实参将自己的地址传递给形参。这是一种双向传递形参的变化会直接影响带实参。缺点是阅读性较差。使用引用作为函数参数。当进行函数调用时在内存中并没有产生实参的副本它是直接对实参操作。这种方式是双向传递形参的变化会直接影响到实参。与指针作为函数参数相比它更容易使用、更清晰。当参数传递的数据较大时用引用比一般变量传递参数的效率要高所占用空间更少。
内联函数
在程序设计中效率是一个很重要的指标。在C语言中保护效率的一个方法是使用宏(Macro)。宏可以不用函数调用但看起来像函数调用。宏是用预处理器来实现的。预处理器直接用宏代码代替宏调用因此就不需要函数调用所需的保存调用时的现场状态和返回地址、进行参数传递等的时间花费。然而C的预处理器不允许存取私有数据这意味着预处理器宏在用作成员函数时变得非常无用。为了既保持预处理器宏的效率又增加安全性而且还能像一般成员函数一样可以在类里访问自如C引入了内联函数(Inline Function)。内联函数时一个函数它与一般函数的区别是在使用时可以像宏一样展开所以没有函数调用的开销。因此使用内联函数可以提高系统的执行效率。但在内联函数体中不能含有复杂的结构控制语句如语句switch和while等。内联函数实际是一种空间换时间的方案因此其缺点是增大了系统空间方面的开销。在类内给出函数体定义的成员函数被默认为内联函数。
内联函数的定义格式为inline 返回值类型 函数名(形式参数表){//函数体}
例如大小写字母转换
#include iostream
using namespace std;
inline char Trans(char ch){if(ch a ch z) return ch - 32;else return ch 32;
}int main(){char ch;while((ch getchar()) ! \n)cout Trans(ch);cout endl;return 0;
}【注】
内联函数代码不宜太长一般是1~5行代码而且不能含有复杂的分支或循环语句等。在类内定义的成员函数默认为内联函数。在类外给出函数体的成员函数若要定义为内联函数则必须加上关键字inline。否则编译器将它作为普通成员函数。递归调用的函数不能定义为内联函数。
函数重载
函数名可以看作一个操作的名字。当多个函数实现的是同一类功能只是部分细节不同如参数的个数或参数类型不同时C提供了函数重载机制即将这些函数取成相同的名字从而时程序已于阅读和理解方便记忆和使用。
函数重载实质两个或两个以上的函数具有相同的函数名但其参数类型不一致或参数个数不同。函数重载包括非成员函数的重载和成员函数重载。
非成员函数重载
非成员函数重载是指对用户所编写的那些功能相同或类似、参数个数或类型不同的用户自定义函数C可以采用相同的函数名从而提高程序的可读性。支持函数重载时C多态性的体现之一。
例如求两个数的积
#include iostream
using namespace std;
int Mul(int x, int y){return x * y;
}
double Mul(double x, double y){return x * y;
}int main(){int x, y;double a, b;cout input x, y:;cin x y;cout x*y Mul(x, y) endl;cout input a, b:;cin a b;cout a*b Mul(a, b) endl;return 0;
}【注】 重载函数必须具有不同的参数个数或不同的参数类型若只是返回值的类型不同或参数名不同时不行的。 重载函数应满足函数名相同函数的返回值类型可以相同也可以不同当各函数的参数表中的参数个数或类型必须有所不同这样才能进行区分从而正确地调用函数。 匹配重载函数的顺序a.通过内部类型转换寻求一个匹配若找到则调用该函数b.通过强制类型转换寻求一个匹配若找到则调用函数。 不能将不同功能的函数定义为重载函数以免产生误解。 创建重载函数时必须让编译器能区分两个或更多的重载函数。当创建的多个重载函数编译器不能区分时编译器就认为这些函数具有多义性即调用是错误的编译器不会编译该程序。例如 #include iostream
using namespace std;
float Mul(float x){return 2 * x;
}
double Mul(double x){return 2 * x;
}int main(){cout Mul(10.2) endl;cout Mul(10) endl;//错误。产生二义性return 0;
}报错 error: call of overloaded Mul(int) is ambiguous400 | cout Mul(10) endl;//错误。产生二义性
| ~~~^~~~note: candidate: float Mul(float)391 | float Mul(float x){| ^~~note: candidate: double Mul(double)394 | double Mul(double x){| ^~~当函数的重载带有默认参数值时要避免产生二义性。
成员函数重载
成员函数重载主要是为了适应相同成员函数的参数多样性。成员函数重载的一个很重要的应用就是重载构造函数。因为构造函数的名字预先有类的名字确定所以只能有一个构造函数名。但在解决实际问题时可能会需要创建具有不同形态的对象因此C提供了函数重载机制。通过对构造函数进行重载可以实现定义对象时初始化赋值的多样性。但是析构函数不能重载因为一个类中只允许有且仅有一个析构函数。
例如求了两个复数的和
#include iostream
using namespace std;
class Complex{
public:Complex(double r, double i):real(r),imag(i){}Complex(double r):real(r),imag(0){}Complex():real(0),imag(0){}Complex Add(Complex a){Complex temp;temp.real real a.real;temp.imag imag a.imag;return temp;}void Print(){cout real;if(imag 0) cout ;if(imag ! 0) cout imag i endl;}
private:double real, imag;
};int main(){Complex com1(1.1, 2.2), com2(3.3, 4.4), com3(5.5), total;total com1.Add(com2);total.Print();total com1.Add(com3);total.Print();return 0;
}运行结果
4.46.6i
6.62.2i函数的默认参数值 当函数既有声明和定义时默认参数值只能在声明中指定不能再函数定义中指定。 void Fun(int x 0, int y 0);//正确在函数声明中指定默认参数值
void Fun(int x 0, int y 0){ // ....} //错误不能再函数定义中指定默认参数值在函数声明中所有带默认值的参数都必须出现再没有默认值参数的右边。也就是说一旦开始定义带默认值的参数在其后面就不能再定义没有默认值的参数了。例如 void Fun(int i, int j 0, int k); //错误在函数调用时若某个参数省略则其后面的参数皆应省略而采用默认参数值。例如 Fun(,9);//错误的调用当重载函数带有默认参数值时要注意避免二义性。
友元
类的主要特点之一是数据隐藏类的私有成员或保护成员只能通过其成员函数来访问。那么有没有办法允许再类外对某个对象的私有成员或保护成员进行操作C中提供了友元机制来解决这个问题。
友元函数
友元函数不是当前类中的成员函数它不仅可以是一个不属于任何一个类的一般函数非成员函数也可以是另外一个类的成员函数。当函数被声明为一个类的友元函数后它就可以通过对象名访问类的私有成员和保护成员。
非成员函数作为友元函数
非成员函数作为类的友元函数后就可以通过对象访问封装再类内部的数据。声明友元函数的方法是在类的定义中用关键字friend进行声明格式为friend 函数返回值 函数名(形参表);
例如使用友元函数将百分制学生的成绩转换成相应的分数等级。
#include iostream
#include iomanip
#include cstringusing namespace std;
class Student{
public:Student(char na[], int sco){strcpy_s(name, strlen(na) 1, na);score sco;}friend void Trans(Student *s){if (s-score 90) strcpy_s(s-level, strlen(优) 1, 优);else if(s-score 80) strcpy_s(s-level, strlen(良) 1,良);else if(s-score 70) strcpy_s(s-level, strlen(中) 1,中);else if(s-score 60) strcpy_s(s-level, strlen(及格) 1,及格);else strcpy_s(s-level, strlen(不及格) 1,不及格);}void Print(){cout name setw(10) score setw(8) level endl;}
private:char name[10];int score;char level[7];
};int main(){Student stu[] {Student(李明, 76), Student(李华, 82), Student(王明, 96), Student(星星, 52)};cout 输出结果 endl;cout 姓名 setw(10) 成绩 setw(8) 等级 endl;for(int i 0; i 4; i){Trans(stu[i]);stu[i].Print();}return 0;
}运行结果
输出结果
姓名 成绩 等级
李明 76 中
李华 82 良
王明 96 优
星星 52 不及格【注】 非成员函数成为类的友元函数后若再类外定义则不能再函数名前加”类名::“因为他不是该类的成员函数非成员函数作为类的友元函数没有this指针调用友元函数时必须在其实参标中给出要访问的对象。 友元函数既可以在类的私有部分进行声明也可以再类的公有部分进行声明。 当一个函数需要访问多个类时应该把这个函数同时定义为这些类的友元函数这样该函数才能访问这些类的私有或保护成员例如。 #include iostream
using namespace std;
class Time;
class Date{
private:int year, month, day;
public:Date(int y, int m, int d):year(y),month(m),day(d){}friend void Calcutetime(Date d, Time t);
};
class Time{
private:int hour, minute, second;
public:Time(int h, int m, int s):hour(h),minute(m),second(s){}friend void Calcutetime(Date d, Time t);
};
void Calcutetime(Date d, Time t){int mom[12] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};int days d.day, total;for(int i 1; i d.month; i){days days mom[i - 1];}if((d.year % 4 0 d.year % 100 ! 0 || d.year % 400 0) d.month 3) days days 1;total ((days * 24 t.hour) * 60 t.minute) * 60 t.second;cout d.year - d.month - d.day ;cout t.hour : t.minute : t.second endl;cout total time: total seconds endl;
}
int main(){Date d(2018, 11, 13);Time t(14, 20, 25);Calcutetime(d, t);return 0;
}若友元函数带了两个不同的类的对象其中一个对象所对应的类要在后面声明。
类的成员函数作为友元函数
一个类的成员函数可以作为另一个类的友元函数这种成员函数不仅可以访问自己所在类中的成员还可以通过对象名访问friend声明语句所在类的私有成员和保护成员从而使两个类相互合作。
#include iostream
using namespace std;
class Time;
class Date{
private:int year, month, day;
public:Date(int y, int m, int d):year(y),month(m),day(d){}void Calcutetime(Time t);
};
class Time{
private:int hour, minute, second;
public:Time(int h, int m, int s):hour(h),minute(m),second(s){}friend void Date::Calcutetime(Time t);
};
void Date::Calcutetime(Time t){int mom[12] {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};int days day, total;for(int i 1; i month; i){days days mom[i - 1];}if((year % 4 0 year % 100 ! 0 || year % 400 0) month 3) days days 1;total ((days * 24 t.hour) * 60 t.minute) * 60 t.second;cout year - month - day ;cout t.hour : t.minute : t.second endl;cout total time: total seconds endl;
}
int main(){Date d(2018, 11, 13);Time t(14, 20, 25);d.Calcutetime(t);return 0;
}友元类
友元函数可以使函数能够访问某个类中的私有或保护成员。若类A的所有成员函数都想访问类B的私有或保护成员一种方法使将类A的所有成员函数都声明为类B的友元函数但这样会让程序显得冗余。为此C提供了友元类。一个类也可以作为另一个类的友元类。若类A声明为类B的友元类则类A中的每个成员函数都具有访问类B的保护或私有数据成员的特权方法如下
class A{//.....void fa();
};
class B{//.....friend class A;
};例如将一个复数转换为二维向量
#include iostream
using namespace std;
class Complex{
private:double real, imag;
public:Complex(double r, double i):real(r),imag(i){}friend class Vector;
};
class Vector{
private:double x, y;
public:void Change(Complex c){x c.real;y c.imag;}void Print(Complex c){cout 复数 c.real;if(c.imag 0) cout ;cout c.imag i endl;cout 二维向量 ( x , y ) endl;}
};
int main(){Complex c(1.2, 3.4);Vector v;v.Change(c);v.Print(c);return 0;
}【注】友元关系是单向的。若类A是类B的友元则类A中的所有成员函数都可以直接访问类B的保护或私有数据成员。但反过来类B中的所有成员函数不能访问类A中的保护和私有成员。友元关系不能进行传递。友元在声明时即可以放在类的私有部分也可以放在类的公有部分。
静态成员
C允许在函数内部创建一个static对象这个对象将存储在程序的静态数据区中而不是在堆栈中它只在函数第一次调用时初始化一次以后将在两次函数之间保持其值。
静态数据成员
当声明一个类后考研建立该类的多个对象每个对象都有类中所定义数据成员的拷贝对应不同的存储空间各个对象相互独立实现了数据的封装与隐藏。但在有些情况下类中的某个数据成员是该类所有对象所共有的若采用数据成员的定义方法则不能实现数据成员的共享。C为此提供了静态数据成员类的静态数据成员拥有一块单独的存储区不管用户创建了多少个对象所有这些对象的静态数据成员都共享这块静态存储区进而为这些对象提供了一种互相通信的方法。
静态数据成员的定义格式为static 类型名 静态成员名;
静态数据成员的初始化格式类型 类名::静态数据成员初始化值;
例如
#include iostream
#include iomanip
#include cstringusing namespace std;
class Student{
private:char *name;int no;float score;static int total;//定义静态数据成员
public:Student(char *na, int sno, float sco):no(sno),score(sco){name new char(strlen(na) 1);strcpy_s(name, strlen(na) 1, na);total;}~Student(){delete []name;}void Print(){cout 第 total 个学生 name setw(4) no setw(4) score endl;cout 总学生人数 total endl;}
};
int Student::total 0;//初始化静态数据成员
int main(){Student s1(张明, 1, 90);s1.Print();Student s2(张三, 2, 85);s2.Print();return 0;
}运行结果
第1个学生张明 1 90
总学生人数1
第2个学生张三 2 85
总学生人数2【注】
静态数据成员的声明需加关键字static访问格式类名::静态数据成员名静态数据成员的初始化应在类外生命并在对象生成之前进行。默认时静态成员被初始化为零。静态数据成员在编译时创建并初始化不能用构造函数进行初始化。静态数据成员不能再任何函数内分配存储空间和初始化。
静态成员函数
与静态数据成员一样用户也可以创建静态成员函数静态成员函数不能访问一般的数据成员和成员函数它只能访问静态数据成员和其他的静态成员函数。静态成员函数时独立于类对象而存在的因此没有this指针。
静态成员函数的定义格式为static 返回类型 静态成员函数名(参数表);
调用格式为类名::静态成员函数名(实参表);
静态对象
在定义对象时可以定义类的静态对象静态对象的析构函数是在主函数结束时才自动执行的与普通对象相同静态对象的析构函数和构造函数的执行顺序相反。
静态对象定义格式static 类名 静态对象名;
例如
#include iostream
#include iomanip
#include cstringusing namespace std;
class Student{
private:char name[10];
public:Student(char na[]){strcpy_s(name, strlen(na) 1, na);cout inside construct: name endl;}~Student(){cout inside destruct: name endl;}
};
void Fun(){static Student s2(Student B);Student s3(Student C);
}
Student s1(Student A);
int main(){cout inside main endl;Fun();Fun();cout outside main endl;return 0;
}运行结果
inside construct:Student A
inside main
inside construct:Student B
inside construct:Student C
inside destruct:Student C
inside construct:Student C
inside destruct:Student C
outside main
inside destruct:Student B
inside destruct:Student A
