c++复习回顾(2)

 一.函数

1.函数定义

eg. int fact(int n);

函数返回类型  函数名 （类型  作用参数）

*函数作用过程中，实参的值拷贝给形参，作用结果对外界(实际参数)不造成影响;

*返回仅有一个出口

2.函数没有返回值时 返回类型定义为void

eg. void fact (int n)

{

        printf("%d\n",n);

}

3.多个形参存在时，必须把每个形参的类型都写出来

eg. void fn(int a,int b,char c);

4.函数传入引用类型，对形参的作用会影响到实参，可以返回多个数据

5.在函数中对数组的修改，会影响函数外面的数组，函数一维数组形参可以省略元素个数，调用数组时输入数组名即可

void output(int a[])
{
    for(int i=0;i<10;i++) cout<<a[i]<<endl;
}
int main()
{
    int b[10];
    output(b);

    return 0;
}

6.多维数组除第一维外，其余维度大小必须定义

void fn(int a[][3][4]);

7.函数内部可以调用函数本身，例如函数递归

#include<iostream>
using namespace std;

int fn(int n)
{
    if(n==1||n==2) return 1;
    else return fn(n-1)+fn(n-2);
}//斐波那契数列

int main()
{
    int n;
    cin>>n;
    cout<<fn(n)<<endl;

    return 0;
}

二.类,结构体，指针,引用和指针

1.类和结构体

a)基本概念

#include<iostream>
using namespace std;

const int N = 10;

//把每个类定义为一个人，把一个人的信息放到一块儿
class Person
{
    private://表示在其范围内的变量和函数是私有的，不能在该类外调用
        int age,height;
        double money;
        string books[N];
        

    public://公有的
        string name;

        //定义的函数
        void say()
        {
            cout<<"I'm"<<name<<endl;
        }
        
        int get_age()
        {
            return age;
        }

        void add_money(double x)
        {
            money+=x;
        }
};//定义的类一定要加分号

int main()
{
    Person c;
    c.name="Mike";
    //c.age=18;//错误！年龄在类的定义中是私有的    
    cout<<c.get_age()<<endl;//因为没有赋初始值，输出是随机的

    c.add_money(1000000);

	return 0;
}

*结构体和类大致是相同的，区别在于，在类中，public 不写时，默认为private；而在结构体中默认为public;

b)定义

class Person{

~~~

}c,persons[100];

或是

Person persons[100];

c)类和结构体的构造函数

#include<iostream>
using namespace std;

struct Person
{
    int age,height;
    double money;
    
    //Person() {} ①

    Person(int _age,int _height,double _money)//要求构造函数名称与结构体保持一致
    {
        age = _age;
        height = _height;
        money = _money;
    }
    //构造函数的另一种赋值方法,运行效率会更快一些
    //Person(int _age,int _height,double _money) : age(_age),height(_height),money(_money) {}
};

int main()
{
    Person p(18,187,100.0);//若构造函数，必须传入函数做需要的值
    //Person p;会报错，解决：定义一个空函数，默认调用空函数 ①   
	cout<<p.age<<endl;
	
    return 0;
}

d)赋初值

Person p={18,180}//会按定义的顺序，顺序赋初值，没有赋初值的默认为零

*注意：若有构造函数，赋值个数必须与其中一个函数参数个数相等，以满足一一对应

2.指针和引用

        *全局变量和静态会存放在 堆 中，默认初始值为零；局部变量，放在 栈 中，值随机;堆空间从下往上分配，栈空间从上往下分配

        地址和变量的关系相当于地址是存放变量的下标

a)指针指向存放变量的地址，因此我们可以通过指针来改变变量的值

b)char c='a';

   cout<<(void*)&c<<endl;//输出字符地址

c)

#include<iostream>
using namespace std;

int main()
{
    int a = 10;
    int *p = &a;//定义指针，赋地址,int *表是指针类型，变量是p
    
    cout<<*p<<endl;//*是取出地址中的值的操作符，注意与上面定义指针加以区分

    *p = 12;//改变地址中的值的同时改变了a的值
    cout<<a<<endl;

    return 0;
}

d)数组指针

        int a[3]={1,2,3};

        cout<<a<<endl;//输出的是数组的首地址，数组名就是一个指针

        *相邻地址间隔有所定义类型的字节数决定

        &a[1] <==>a+1

c)int* p = &a;//指针

   int& p = a; //引用，别名，此时p和a等价，可以看成同一个东西

d)链表（算法中的某种结构）

#include<iostream>
using namespace std;

struct Node{
	int val;
	Node* next;
	
	Node(int _val) : val(_val),next(NULL) {}//传值 
};

int main()
{
	//Node node = Node(1);也是一种合法的定义方式 
	//Node* p = &node;先定义一个链表结点node变量，再放到指针中 
	Node* p = new Node(1);//和上两行等价 ，new函数相当于 生成一个结构体，并放到指针中 
	Node* q = new Node(2);
	Node* o = new Node(3);
	
	p->next = q;//p是指针，用'->'访问成员变量 ,否则用'.'访问成员变量,取决于前面变量类型 
	q->next = o;
	
	Node* head = p;//头结点 （地址）存放于head中 
	
	//在开头添加一个新的结点 
	Node* u = new Node(4);
	u->next = head;
	head = u;
	
	//链表的删除 ，遍历不到该点即可，让head的next指向下一个 
	head->next = head->next->next; 
	 
	
	//链表的遍历方式
	for(Node* i = head; i ;i=i->next) cout<<i->val<<endl;
	
	return 0; 
}