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

最新推荐文章于 2024-08-19 23:47:24 发布
最新推荐文章于 2024-08-19 23:47:24 发布
阅读量1.1k 收藏 10
点赞数 1
分类专栏： 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TI__boyue/article/details/108694658
版权

目录

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

在这里插入图片描述

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

程序运行后：栈区，堆区

在这里插入图片描述
数据保留一次

在这里插入图片描述

//栈区：局部变量
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++面向对象笔记整理
weixin_52215765的博客
04-09 210
C++中在程序 运行前：分为全局区（放置（静态static）变量，（字符串）常量const）和代码区（共享和只读） 运行后：栈区 由编译器自动分配释放, 存放函数的参数值,局部变量等 注：不要返回局部变量的地址（一般只保留一次）(不要返回局部变量引用)，栈区开辟的数据由编译器自动释放 堆区：new，由程序员分配释放delete,若程序员不释放,程序结束时由操作系统回收 关于new 语法：new +数据类型， 利用new创建的数据，会返回该数据对应的类型的指针（地址，解引用） eg：int* func()
【黑马程序员】C++学习笔记--核心篇
2401_82949788的博客
02-21 974
堆区数据由程序员管理开辟和释放堆区数据利用new关键字进行开辟内存。
C++基础入门学习笔记
weixin_43544679的博客
08-12 7204
C++基础入门 1.1 hello world #include<iostream> using namespace std; int main() { cout << "Hello world" << endl; system("pause"); return 0; } 1.2 注释 作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码 两种格式 单行注释：// 描述信息 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明
黑马程序员C++自学笔记
最新发布
qq_66734705的博客
08-19 685
struct 结构体名 {结构体成员列表}；struct 结构体名 变量名struct 结构体名 变量名 = {成员1值，成员2值……}定义结构体时顺便创建变量定义结构体时的关键字是struct，不可省略创建结构体变量时，关键字struct可以省略结构体变量利用操作符"."访问成员作用：函数名可以相同，提高复用性同一个作用域下函数名相同函数参数的类型不同，或者个数不同，或者顺序不同注意：函数的返回值不可以作为函数重载的条件概述：多态是C++面向对象三大特征之一多态分为两类。
C++黑马程序员 笔记
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
07-27 180
C++黑马程序员 笔记
C++核心编程（黑马程序员笔记）
念去去
07-06 7217
C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序编译后，生成了ex
C++核心编程4— 类和对象
果果小师弟的博客
09-20 1107
C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： ​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌… ​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调… ​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类 4.1 封装 4.1.1 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制 封装意义一：
黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义》是为C++初学者量身定制的一份详细教学资源。这份讲义深入浅出地介绍了C++编程语言，并通过实际的机房预约系统项目，帮助学习者将理论知识与实践相...
B站《黑马程序员匠心之作-C++教程从0到1入门编程,学习编程不再难》 配套笔记
07-31
2. **第2阶段实战-通讯录管理**：这一阶段可能涉及面向对象编程的基本概念，如类和对象，以及如何设计和实现一个简单的通讯录管理系统，可能包括增删查改等功能。 3. **附-C++编程环境搭建教程**：这部分指导如何...
c++入门，核心，提高讲义笔记
11-27
C++是一种强大的编程语言，广泛应用于系统开发、游戏编程、软件工程等领域。本文将深入讲解C++的基础知识，包括入门、核心概念以及提高技巧...持续学习和实践是成为C++大师的关键，这份讲义笔记将帮助你迈好这第一步。
Python学习日记（初级篇02面向对象之基础）——黑马程序员视频学习笔记
幕光倾城的博客
03-10 7846
Python学习日记（初级篇02面向对象之基础) 这是学习Python的面向对象的第一个部分，总共有四个部分。 本人在b站学习免费课程“黑马程序员Python教程_600集Python从入门到精通教程（懂中文就能学会）”，边学习边记录。
黑马程序员C++学习笔记（第二阶段核心：面向对象）（二）
TI__boyue的博客
10-14 662
目录C++对象模型和this指针成员变量和成员函数分开存储this 指针 C++对象模型和this指针 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上面(类对应的对象的内存大小不会发生改变) 空对象占用内存空间为: C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置 每个空对象也应该有一个独一无二的内存地址 this 指针 每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。那
黑马程序员——C++笔记
老猫的博客
04-01 2623
习题 习题描述 问题集 新手村： cout << "a = " << a << endl; 标识符 第一个字符必须为字母或下划线 cout << (int)ch << endl; //查看字符a对应的ASCII码 sizeof( 数据类型 / 变量) float f1 = 3.14f;//注意这里加了个f 这样加的好处是之后不用再进行转换，一步到位 //ch = “abcde”; //错误，不可以用双引号 //ch =
黑马程序员C++笔记
m0_62076827的博客
01-12 4159
黑马程序员C++笔记
黑马程序员C++学习笔记
jinxiqinghuan的博客
02-07 1022
1.关于if语句使用的逻辑问题【未解决】 /*这里可以书写多行注释 版权：copyright*/ #include<iostream> using namespace std; int main() { //选择结构 单行if语句 float score = 0; cout << "请输入你的分数" << endl; ...
黑马程序员c++学习笔记
breakdown1112的博客
12-04 4538
test
【黑马程序员C++】学习笔记
m0_51913750的博客
03-15 2660
黑马程序员C++学习笔记
黑马程序员C++学习笔记（第一阶段：基础）
TI__boyue的博客
09-20 1555
目录起步：hello c++定义常量：# define ,const 起步：hello c++ #include <iostream> using namespace std; int main(){ cout <<"hello c++"<< endl; // system("pause"); return 0; } 定义常量：# define ,const #define 宏变 ...
C++学习笔记：面向对象与实例化对象存储解析
"这篇文档是关于C++学习的笔记，主要探讨了实例化对象的存储问题...通过学习这篇笔记，读者不仅可以了解到对象存储的细节，还能深入理解C++语言的核心特性和发展历程，这对于C++初学者和进阶者都是一份宝贵的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值