内存分区：代码区，全局区，栈区，堆区
- 程序运行前：代码区，全局区
- 程序运行后：栈区，堆区
引用--给变量起别名
- 注意事项
- 引用做函数参数
- 引用做函数返回值
- 引用的本质---指针常量(值可变，指向不可变)
- 常量引用
函数提高
- 默认参数
- 函数占位参数
- ☆函数重载
☆☆类和对象：封装，继承，多态
- 封装: 权限，属性，方法
- - 属性，方法
  - 访问权限: public protected private
  - struct 和 class 区别 : 默认访问权限不同
  - 成员属性设置为私有private
- 对象的初始化和清理--构造函数(初始化)，析构函数(清理)
- - 构造函数和析构函数
  - 构造函数的分类及调用:两分类三调用
- 拷贝构造函数调用时机
- - 存在问题(返回值优化)：vs和vscode运行结果不同
- 构造函数调用规则
- ☆深拷贝与浅拷贝（释放内存）
- 初始化列表（初始化属性）
- 类对象作为类成员
- 静态成员（成员变量，成员函数，static）

内存分区：代码区，全局区，栈区，堆区

程序运行前：代码区，全局区

程序运行后：栈区，堆区

数据保留一次

//栈区：局部变量
int a=10;
// 堆区:程序员开辟new，释放delete,
int *p=new int(10); // 返回的是整型数据10存放的地址编号

int *p = new int(10); //开辟
delete p; //释放

int *arr = new int[10]; //10个元素 返回首地址\
for(int i=0;i<10;i++){arr[i]=100+i;
}
delete[] arr;

引用–给变量起别名

数据类型 &别名 = 原名

int a=10;
int &b=a; //别名 b ，指向同一块内存

注意事项

引用必须初始化；

error: int &b;

引用初始化后不可以改变（不可以再当其他变量的别名）

int &b=a;
int c=20;
error: &b=c;

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参；
优点：可以简化指针修改实参；

#include <iostream>
using namespace std;void swap(int &a,int &b){int temp;temp=a;a=b;b=temp;
}int main(){int a=10,b=20;swap(a,b);cout<<"a:"<<a<<endl;cout<<"b:"<<b<<endl;//system("pause");return 0;
}

引用做函数返回值

notice： 不要返回局部变量引用；---可以返回静态变量引用
返回引用，则函数调用可以作为左值；

#include <iostream>
using namespace std;int& test(){// 静态变量，存放在全局区，全局区上的数据在程序结束后由系统释放static int a=10; return a;
}int main(){// ref 指向 a对应的内存空间int &ref=test();cout<<ref<<endl;cout<<ref<<endl;// 修改原值 ：可看做直接对a进行操作test()=100; cout<<ref<<endl;cout<<ref<<endl;return 0;
}

引用的本质—指针常量(值可变，指向不可变)

常量引用

修饰形参，防止误操作

#include <iostream>
using namespace std;int showData(const int &a){//a=10;cout<<a<<endl;
}int main(){int a=100;const int &ref=10;showData(a);return 0;
}

函数提高

默认参数

注意事项
如果某个位置已经有默认参数，呢么从这个位置往后，从左到右都必须有默认值；
如果函数声明有默认参数，函数实现就不能有默认参数；(error：重定义默认参数)

函数占位参数

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

返回值类型 函数名 (数据类型){}
void func(int a,int)

☆函数重载

作用：函数名可以相同，提高复用性
注意： 函数返回值不可以作为函数重载的条件

函数重载需满足条件：

同一个作用域下；
函数名相同；
函数参数类型不同或个数不同或顺序不同

注意事项：（坑）

引用作为重载条件
函数重载碰到函数默认参数；(二义性)

☆☆类和对象：封装，继承，多态

封装: 权限，属性，方法

属性，方法

class 类名{ 访问权限： 属性 / 行为};

#include <iostream>
using namespace std;const double PI=3.14;class Cricle{// 访问权限// 公共权限public:// 属性int r;// 行为double calculateZc(){return 2*PI*r;}
};int main(){//对象Cricle c1;c1.r=10;cout<<c1.calculateZc()<<endl;// system("pause");return 0;
}

#include <iostream>
#include<string>using namespace std;class Student{public:string Name;int Id;void showStudent(){cout<<Name<<endl;}void setData(string name,int id){Name=name;Id=id;}// void setId(int id){//     Id=id;// }
};int main(){Student st1;st1.setData("string",1001);st1.showStudent();// system("pause");return 0;
}

访问权限: public protected private

struct 和 class 区别 : 默认访问权限不同

#include <iostream>
#include<string>using namespace std;class Test1{// 默认 私有 权限int a;
};
struct Test2{// 默认 公共 权限int a;
};int main(){Test1 t1;Test2 t2;//t1.a=10;t2.a=10;// system("pause");return 0;
}

成员属性设置为私有private

优点
将所有成员属性设置为私有，可以自己控制读写权限；
对于写权限，我们可以检测数据的有效性；(数据是否符合要求)

在类中可以让另一个类作为本来的成员；
把不同的类放在不同的文件中；

对象的初始化和清理–构造函数(初始化)，析构函数(清理)

构造函数和析构函数

构造函数的分类及调用:两分类三调用

class Person{public:// 初始化：构造函数 // 创建对象时构造函数会自动调用，且每个对象仅调用一次// 没有返回值，不用写void；// 函数名与类名相同；// 构造函数可以有参也可以无参，可以发生重载Person(){cout<<"person默认构造函数的调用"<<endl;}//有参构造函数Person(int a){age=a;cout<<"person有参构造函数的调用"<<endl;}//拷贝构造函数Person(const Person &p){// 将传入的对象的所有属性拷贝过来age=p.age;cout<<"person拷贝构造函数的调用"<<endl;}// 清理：析构函数// 释放对象时调用// 没有返回值，不用写void；// 函数名与类名相同；// 析构函数无参，不可以发生重载~Person(){cout <<"person析构函数的调用"<<endl;}private:int age;
};

// 1.括号法// Person p1; //默认构造函数调用// Person p2(10); // 有参构造函数// Person p3(p2); // 拷贝构造函数 // 注意事项// 调用默认函数时，不要加() Person p1();// 因为编译器会认为这是一个函数的声明 : void func();

    // 2.显示法// Person p1;// Person p2 = Person(10);// Person p3 = Person(p2);// Person(10); 匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象// 注意// 不要利用拷贝构造函数 初始化匿名对象 Person(p3)// 因为编译器会认为是对象声明 Person(p3) 等价于 Person p3;

拷贝构造函数调用时机

使用一个已经创建完毕的对象来初始化一个新对象

Person p3(p2);

值传递的方式给函数参数传值

void dowork(Person p){}
void test02(){Person p;dowork(p); // 实参传给形参，形参创建对象
}

以值方式返回局部对象

Person dowork2(){Person p1;return p1;
}
void test03(){Person p2=dowork2()
}

存在问题(返回值优化)：vs和vscode运行结果不同

#include<iostream>
#include<string>using namespace std;class Person {public:Person() {cout << "person默认构造函数的调用" << endl;}//有参构造函数Person(int a) {age = a;cout << "person有参构造函数的调用" << endl;}//拷贝构造函数Person(const Person &p) {// 将传入的对象的所有属性拷贝过来age = p.age;cout << "person拷贝构造函数的调用" << endl;}~Person() {cout << "person析构函数的调用" << endl;}private:int age;
};Person dowork2() {Person p1;cout << &p1 << endl;return p1;
}
void test03() {Person p2 = dowork2();cout << &p2 << endl;
}int main() {test03();system("pause");return 0;
}

问题解析点击这里

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数(对属性进行值拷贝)

构造函数调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不会再提供其他默认构造函数

拷贝构造函数《----有参构造函数《-----默认构造函数；

☆深拷贝与浅拷贝（释放内存）

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作

堆区的数据内存重复释放，解决方法可进行深拷贝操作，即重新定义一块内存

深拷贝：在堆区重新申请空间，进行拷贝操作

#include<iostream>
using namespace std;class Person {public:Person() {cout << "person 的默认构造函数" << endl;}Person(int a, int height) {cout << "person 的有参构造函数" << endl;age = a;Height = new int(height);//堆区}Person(const Person &p) {cout << "person 的默认构造函数" << endl;age = p.age;// 浅拷贝// Height = p.Height; // 编译器默认实现// 深拷贝Height = new int(*p.Height);}~Person() {// if (Height != NULL) {delete Height;Height = NULL;}cout << "person 的析构函数" << endl;}int age;int *Height;
};int main() {Person p1(18, 170);cout << "p1的年龄为" << p1.age << " p1的身高为" << *p1.Height << endl;Person p2(p1);cout << "p2的年龄为" << p2.age << " p2的身高为" << *p2.Height << endl;return 0;
}

初始化列表（初始化属性）

 Person(int a,int b,int c):A(a),B(b),C(c){}

#include<iostream>
using namespace std;class Person{public ://初始化列表赋值Person(int a,int b,int c):A(a),B(b),C(c){}int A;int B;int C;
};int main() {Person p(30,20,12);cout<<p.A<<endl;cout<<p.B<<endl;cout<<p.C<<endl;return 0;
}

类对象作为类成员

当其他类对象作为本类成员时，
构造对象时先构造类对象，再构造自身；
析构时顺序相反；

#include<iostream>
#include<string>
using namespace std;class Phone{public:Phone(string name){types=name;}string types;
};class Person{public:// Phone apple = types; // 隐式转换法Person(string name,string types):Name(name),apple(types){}string Name;Phone apple;
};int main() {Person p("zhangsan","苹果");cout<<p.Name<<p.apple.types<<endl;return 0;
}

静态成员（成员变量，成员函数，static）

静态成员分为：静态成员变量，静态成员函数

静态成员函数：

所有对象共享同一个函数
静态成员函数只能访问静态成员变量

静态成员函数可以访问静态成员变量，但不可以访问非静态成员变量；
因为对于非静态成员变量而言，程序无法区分到底是哪个对象的属性

// 静态成员函数static void func(){cout<<"static void func"<<endl;}

// 通过对象访问Person p;p.func();// 通过类名访问Person::func();

静态成员变量：(共用的)

所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化

#include<iostream>
#include<string>
using namespace std;class Person{public:// 静态成员函数static void func(){a=100; // 静态成员函数可以访问静态成员变量cout<<"static void func"<<endl;}// 静态成员变量static int a;
};int Person::a=0;int main() {// 通过对象访问Person p;p.func();// 通过类名访问Person::func();return 0;
}

黑马程序员C++学习笔记（第二阶段核心：面向对象）（一）相关推荐

黑马程序员Maven学习笔记
前言这里是黑马程序员Maven学习笔记分享,这是视频链接. 我还有其它前端内容的笔记,有需要可以查看. 文章目录前言基础 Maven简介 Maven是什么 Maven的作用 Maven的下载 M ...
【C++】黑马程序员 C++学习课程—C++核心编程
[C++]黑马程序员 C++学习课程-C++核心编程黑马程序员 C++学习课件, 为自用版本,单纯为了学习和查找资料更加方便本阶段主要针对C++面向对象编程技术做详细讲解,探讨C++中的核心和精髓 ...
黑马程序员C++学习笔记（第三阶段核心：STL）--- 更新中
目录迭代器序列式容器 vector -- 可随机访问 list -- 不支持随机访问 deque -- 动态关联式容器 -- 红黑树 map multimap set multiset -- 废 ...
黑马程序员Javaweb学习笔记01
该博客主要记录在学习黑马程序员Javaweb过程的一些笔记,方便复习以及加强记忆文章目录一 . BS架构,HTTP协议 http请求数据格式和相应数据格式二 . web服务器 2.1 tomca ...
黑马程序员Javaweb学习笔记02【request和response】
该博客主要记录在学习黑马程序员Javaweb过程的一些笔记,方便复习以及加强记忆
黑马程序员C++学习笔记＜第一阶段_基础篇＞
配套视频网址: 黑马程序员:http://yun.itheima.com/course/520.html?bili B站:https://www.bilibili.com/video/BV1et411 ...
黑马程序员SSM-MyBatisPlus学习笔记
目录一.MyBatisPlus简介 1.1 SpringBoot整合MyBatisPlus入门程序 1.2 MyBatisPlus概述二.标准数据层开发 2.1 标准数据层CRUD功能 2.2 分 ...
【黑马程序员JVM学习笔记】01.引言
1. 什么是JVM? 定义: Java Virtual Machine,Java程序的运行环境(Java二进制字节码的运行环境) 好处: 一次编写,到处运行自动内存管理,垃圾回收功能数组下标越界检 ...
day30 | 黑马程序员Java全程笔记 | 第二阶段MySQL高级 JDBC
01.反馈回顾事务: ★ 概述: 逻辑上的一组操作,组成这组操作的各个单元要么同时成功,要么同时失败. 事务是一个最小的执行单元. mysql中的事务控制: 手动事务: 需要手动开启,提交,回滚开启 ...

黑马程序员C++学习笔记（第二阶段核心：面向对象）（一）

目录