C++语法知识复习1（黑马程序员教程p1-p108）

1、基础语法

最基本的排序算法






不声明函数的话，如果函数在主函数后面，调用时可能会报错！！

让代码结构更加清晰

const修饰后 变成只读，不可修改
const修饰后 变成只读，不可修改
const修饰后 变成只读，不可修改

（指向的内容10不允许修改）

指针常量 常量指针

指针常量

结构体中const的使用

P69 讲到了 值传递的时候是实参复制一份给形参 如果数据量较大，这样的值传递方式比较占内存空间，使用地址传递的方式更加好，会更加节省内存空间，一个指针只占四个内存

P69 讲到了 值传递的时候是实参复制一份给形参 如果数据量较大，这样的值传递方式比较占内存空间，使用地址传递的方式更加好，会更加节省内存空间，一个指针只占四个内存

P69 讲到了 值传递的时候是实参复制一份给形参 如果数据量较大，这样的值传递方式比较占内存空间，使用地址传递的方式更加好，会更加节省内存空间，一个指针只占四个内存

P69 讲到了 值传递的时候是实参复制一份给形参 如果数据量较大，这样的值传递方式比较占内存空间，使用地址传递的方式更加好，会更加节省内存空间，一个指针只占四个内存

防止函数调用时 实参随着形参改变而改变
防止函数调用时 实参随着形参改变而改变
防止函数调用时 实参随着形参改变而改变

const student *s

2、核心编程

内存分区

栈区的数据在函数执行完之后自动释放
栈区的数据在函数执行完之后自动释放
栈区的数据在函数执行完之后自动释放
栈区的数据在函数执行完之后自动释放

函数执行完之后。变量a的地址上的数据就被擦出了，就没法访问到这个数据了。
函数执行完之后。变量a的地址上的数据就被擦出了，就没法访问到这个数据了。
函数执行完之后。变量a的地址上的数据就被擦出了，就没法访问到这个数据了。

（注意：可能编译器不同，略有差异，但是不能用）

利用new关键字创建一个堆区的数据

引用，可以对变量的引用再进行引用，反正都是起别名，

#include <iostream>

using namespace std;
int main()
{
    int num = 2;
    int &ref1 = num;
    int &ref2 = ref1;
    cout << ref2 << endl;
    num = 3;
    cout << ref2 << endl;
    ref2 = 155;
    cout << ref2 << endl;

    
}

引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点
引用做形参 这样的话，形参如果改变，则会改变实参 ------------- 比指针做形参简单点

可以简化指针修改实参
可以简化指针修改实参
可以简化指针修改实参
可以简化指针修改实参
可以简化指针修改实参
可以简化指针修改实参
可以简化指针修改实参

引用做函数返回值

引用做函数的返回值

引用做函数的返回值

引用做函数的返回值

返回本体 return啥 就返回啥（本体）

加个& 就表示按引用的类型进行返回
加个& 就表示按引用的类型进行返回
加个& 就表示按引用的类型进行返回

函数的调用可以作为左值，下面的这个函数返回的是一个引用类型

普通局部变量（存放在栈区里，子函数执行完，变量就被释放掉了）不可以作为函数的返回值，静态局部变量可以！！！

常量引用 Const 用const来修饰形参 防止形参改变实参
常量引用 Const 用const来修饰形参
常量引用 Const 用const来修饰形参 防止形参改变实参
常量引用 Const 用const来修饰形参
常量引用 Const 用const来修饰形参 防止形参改变实参
常量引用 Const 用const来修饰形参

10是一个字面量 不可以被引用

加上Const就可以了

防止对形参进行误操作

函数
特别注意：函数声明和实现的一些注意事项


函数站位参数

占位参数还可以有默认参数

引用作为函数重载




函数重载遇到默认参数

3、类和对象

对象有其属性和行为
对象有其属性和行为
对象有其属性和行为
对象有其属性和行为
对象有其属性和行为

访问权限 属性（数据成员） 行为（成员函数）


封装的意义
将属性和行为写在一起，表现事物


通过函数给数据成员赋值

权限 三种


类内类外是指对于类定义而言的

将成员属性（也就是成员数据）设置为私有
将成员属性（也就是成员数据）设置为私有
将成员属性（也就是成员数据）设置为私有
将成员属性（也就是成员数据）设置为私有
将成员属性（也就是成员数据）设置为私有
将成员属性（也就是成员数据）设置为私有

通过公开的成员函数来控制读取数据成员

可以使用公共public接口函数（set或者get）对私有数据成员进行操作 读取或者设置
可以使用公共public接口对私有数据成员进行操作 读取或者设置
可以使用公共public接口对私有数据成员进行操作 读取或者设置
可以使用公共public接口对私有数据成员进行操作 读取或者设置

用于检测数据的有效性

return 直接返回 结束子函数运行

#include <iostream>
using namespace std;
#include <string>
const double pi = 3.14;
//通过set或者get等公共接口函数函数来控制成员的读取权限
class person
{
    public:
        //设置年龄
        void set(int age1)
        {
            age = age1;
        }
        //读取年龄
        void showage()
        {
            cout << age << endl;
        }

        void showname()
        {
            name = "sss";//先初始化
            cout << name << endl;
        }

        void setlover(string lover1)
        {
            lover = lover1;
        }



    private:
        int age;//可读可写
        string name;//只读
        string lover;//只写
};
int main()
{

    person zhangsan;
    zhangsan.set(15);
    zhangsan.showage();

    return 0;
}

注意：类和结构体也是一种数据类型，只不过是我们自己定义的数据类型

#include <iostream>
using namespace std;
#include <string>


class Point
{
    public:
        void setx(double x1)
        {
            x = x1;
        }
        double getx()
        {
            return x;
        }


        void sety(double y1)
        {
            y = y1;
        }
        double gety()
        {
            return y;
        }

    private:
        double x;
        double y;
};

class Circle
{
    public:
        void setr(double r1)
        {
            r = r1;
        }
        double getr()
        {
            return r;
        }
        void setpoint(Point p)
        {
            point1 = p;
        }
        Point getpoint()
        {
            return point1;
        }


    private:
        Point point1;
        double r;
};

void isIncircle(Point &p,Circle &c)
{
    double distance =
        (p.getx() - c.getpoint().getx()) * (p.getx() - c.getpoint().getx()) + (p.gety() - c.getpoint().gety());
    double r2 = c.getr() * c.getr();

    if(distance==r2)
    {
        cout << "相切" << endl;
    }
    if(distance>r2)
    {
        cout << "相离" << endl;

    }

    if(distance<r2)
    {
        cout << "相交" << endl;
    }
}
int main()
{
    Point point;
    point.setx(-0.2);
    point.sety(0);

    Point point2;
    point2.setx(1);
    point2.sety(0);

    Circle circle;
    circle.setr(1);
    circle.setpoint(point2);

    isIncircle(point, circle);
}

这个例子按照源文件和头文件分开写，会更好！！！
这个例子按照源文件和头文件分开写，会更好！！！
这个例子按照源文件和头文件分开写，会更好！！！、

如下：
Circle.h

Circle.cpp

Point.h

Point.cpp

main.cpp
主要包含全局函数和主函数

#include <iostream>
#include "Point.h"
#include "Point.cpp"

#include "Circle.h"
#include "Circle.cpp"
using namespace std;

void isIncircle(Point &p,Circle &c)
{
    double distance =
        (p.getx() - c.getpoint().getx()) * (p.getx() - c.getpoint().getx()) + (p.gety() - c.getpoint().gety());
    double r2 = c.getr() * c.getr();

    if(distance==r2)
    {
        cout << "相切" << endl;
    }
    if(distance>r2)
    {
        cout << "相离" << endl;

    }

    if(distance<r2)
    {
        cout << "相交" << endl;
    }
}
int main()
{
    Point point;
    point.setx(0.1);
    point.sety(0);

    Point point2;
    point2.setx(1);
    point2.sety(0);

    Circle circle;
    circle.setr(1);
    circle.setpoint(point2);

    isIncircle(point, circle);
}

对象的初始化和清理
通过构造函数和析构函数



把整个main函数都执行完才会执行对象的释放操作，才会执行对象的析构函数
把整个main函数都执行完才会执行对象的释放操作，才会执行对象的析构函数
把整个main函数都执行完才会执行对象的释放操作，才会执行对象的析构函数

对象执行完了 销毁了才会调用析构函数

对象执行完了 销毁了才会调用析构函数

对象执行完了 销毁了才会调用析构函数

创建对象的时候，构造函数被自动调用，且只有一次

const Person &p
const Person &p
const Person &p
const Person &p
const Person &p
const Person &p

复制（拷贝）构造函数

拷贝构造函数
定义看下面例子

    //显示法
    Person p1;
    Person p2 = Person(102);//有参构造
    Person p3 = Person(p2);//拷贝构造

会出现重定义的问题

拷贝构造函数调用时机

值传递的本质就是会临时拷贝一个副本出来，这里就是调用其拷贝构造函数拷贝（创建）一个新的副本对象

值传递的本质就是会临时拷贝一个副本出来，这里就是调用其拷贝构造函数拷贝一个新的副本对象

值传递的本质就是会临时拷贝一个副本出来，这里就是调用其拷贝构造函数拷贝一个新的副本对象

值传递的本质就是会临时拷贝一个副本出来，这里就是调用其拷贝构造函数拷贝一个新的副本对象

上面的原因还有个是因为值方式来返回。。

局部变量的特点，函数执行完之后就会被清理掉（也就是释放掉）

拷贝一个新的对象，返回给外面 也就是p
拷贝一个新的对象，返回给外面 也就是p
拷贝一个新的对象，返回给外面 也就是p

拷贝构造出一个新的对象，，然后传递给p

vscode就给优化了
vscode就给优化了
vscode就给优化了