函数 function
函数定义 （返回类型可有可无，无为void，一个函数可以有多个或者0个参数）
returnType functionName(parameterList)
{
functionBody;
(有返回值则需要返回对应类型的参数)
}
返回类型 函数名（形参列表）
{
函数体
}
函数声明 (函数定义在main（）下则需要在main（）上对函数进行声明)
returnType functionName(parameterList);
函数调用 (有参数则需要传递对应类型的实参)
functionName(paramerterList);
形参和实参
void A(int i){}//函数定义 i为形参
A(5);//函数调用 5为实参
传值参数和传引用参数（实参为值类型则为值参数（原值不动），实参为引用则为引用类型(原值随动)）
void A(int i) {
cout << i << endl;
i=20; //原值不变
}
void B(int* i) {
cout << *i<<endl;
*i=20; //原值改变
}
int main()
{
int a = 10;
int* p;
p = &a;
A(a);
cout<<a<<endl; //a=10
B(p);
cout<<a<<endl; //a=20
return 0;
}
const形参与实参
int num1 = 10; //int类型变量 可以修改值
const int num2 = 10; //int类型常量 不可修改值
num1 = 20;
//num2 = 20; //错误
int* p1 = &num1;
//int* p2 = &num2; //错误
const int* p3 = &num1;
const int* p4 = &num2;
int* const p5 = &num1;
//int* const p6 = &num2; //错误
int &r1 = num1;
//int &r2 = num2; //错误
const int &r3 = num1;
const int &r4 = num2;
void C1(int i) {
i = 10;
}
void C2(const int i) {
//i = 10; //错误
}
void P1(int* p) {
*p = 10;
}
//可以修改p,实参可以是int类型或者const int类型
void P2(const int* p) {
//*p = 10; //错误
}
//不可以修改p，实参只能是int类型
void P3(int* const p) {
*p = 10;
}
void R1(int& r) {
r = 10;
}
void R2(const int& r) {
//r = 10; //错误
}
默认实参
void MR(int i,int j=100) //默认参数必须在后
{
cout << i;
}
MR(10);//调用只需要传递一个参数
MR(10,10);//传递两个则以传入的值为准
函数的返回类型
int Back()
{
return 0;
}
void Back2(){}//无需返回值
递归函数(直接或者间接的调用自己)
//递归求阶乘
int Fic(int i) {
return i== 0 ?1:i * Fic(i - 1);
}
内联函数 inline (在函数声明或者函数定义前加上关键字inline)(优点 程序运行速度快 程序无需跳出到另一个代码块)
( 缺点 占用更多内存 不能递归)(通常做法:省略函数原型 在函数定义时写)
常量表达式函数 constexpr (能用于常量表达式的函数，就是在编译时就算返回值的函数)
（只可以有一个return语句）（返回值必须是字面值类型）(参数必须是字面值类型)（隐式指定为内联函数但是可以递归）
字面值类型：算数类型，引用，指针
非字面值类型：自定义类，IO库,string
函数重载 (同一个作用域 多个函数名相同 但是参数列表不同 称之为函数重载)
int A(){}
int A(int x){} //重载
int A(int x,int y){} //重载
//根据传递参数不同会自动调用对应的重载函数
A();
A(1);
A(1,1);
函数与数组 (函数名 不是数组 是指针 指向数组的第一个元素)
//保护数组不被修改可以 把数组定义为const
int sum(int arr[], int n) {
int t = 0;
arr[0] = 2;//修改数组
for (int i = 0; i < n; i++) {
t += arr[i];
}
return t;
}
int main(){
int arr[] = {1,2,3};
cout<<sum(arr,3)<<endl;
return 0;
}
函数与结构体(结构体在函数中可以和基本类型一样使用 作为参数传递或者作为返回值)
struct W{};
W S(W w1,W w2){return w1+w2}
函数与字符串(字符串在函数中可以和基本类型一样使用 作为参数传递或者作为返回值)
函数指针 (函数有地址 是存储其机器语言代码内存的开始地址 可以将地址作为函数的参数 使第一个函数找到第二个并运行)
（函数的指针指向的是函数不是对象）
//想要声明一个可以指向函数的指针 只需要用指针替换掉函数名即可
bool (*p)(string &,string &);//（*p）不能少
void FP() {
cout << "函数指针" << endl;
}
int main(){
void(*p)();//定义函数指针p
p = FP;//把函数地址赋值给指针p
p();//也可以调用函数
}
分离式编程(a.h a.cpp b.cpp)
a.h（头文件:包含结构声明和使用这些结构的函数原型）
a.cpp(源代码文件：包含与结构有关的函数的代码)
b.cpp(源代码文件：包含调用与结构相关的函数的代码，main函数在这里)
类 class
面向对象编程的特性：
抽象
封装和数据隐藏
多态
继承
代码的可重用性
类的基本思想是数据抽象和封装
(数据抽象一种依赖于接口和实现分离的编程技术)
（封装就是将抽象出的数据成员，行为成员相结合，将他们视为一个整体）
(封装实现了类的接口和实现的分离)
类声明：以成员数据的方式描述数据部分，以成员函数的方式描述公有接口
类方法定义：描述如何实现类成员函数
（通常接口放在.h中，实现放在.cpp中,调用在main函数中在另外一个.cpp文件中）
//公共成员函数可以访问私有成员
Student.h文件
class Student //类声明 class+类名 不分配内存
{
friend void F(Student &s);//友元函数
private://私有成员
string name; //
int age; // 数据成员
char sex; //
public://共有成员
Student(string name,int age,char sex);//带参数的构造函数
~Student();
void PrintInformation();//成员函数声明
};
Student.cpp文件
#include "Student.h"
Student::Student(string n, int a, char s)//构造函数的实现 一般用来初始化数据成员
{
this->name = n; //使用指针访问 name
age = a;
sex = s;
}
void Student::PrintInformation() //类方法定义(方法实现)
{
}
Student::~Student()//使用构造函数创建对象后，程序负责跟踪该对象，直到对象过期时，程序自动调用析构函数，完成清理
{
}
void F(Student &s)
{
}
Main.cpp文件
#include"Student.h" //需要包含.h进来
int main(){
Student s;//声明 类对象 分配存储空间
s.PrintInformation();//通过类对象.方法名调用公有方法
Student s1 = Student("Far",23,'m');//显示调用构造函数
Student s2("Far",23,'m');
F(s); //友元函数不是类的成员函数 不能直接访问 需要通过对象访问
return 0;
}
this指针 (每一个对象都能通过this指针访问自己的地址)
对象用 . 指针用 ->
对象数组
Student s[5];
类作用域 (在类外，普通的数据和函数只能通过对象，引用，指针使用成员访问运算符来访问)
使用static关键字
static const int a= 60;//这样定义的 a 等价于60
没有评论:
发表评论