C++ 基础

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量480 收藏 8
点赞数 5
分类专栏： 编程语言 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a152419/article/details/137884016
版权

1. 引用

1.1. 什么是引用

作用：给变量起别名

语法：数据类型 &别名 = 原名；

本质：引用的本质是在 C++ 内部实现的一个常量指针。

特点：

  • 引用必须初始化。
  • 引用初始化后，不可以改变。

1.2. 引用使用方法

//引用的本质
int &b = a;  //相当于 int* const b = &a;

------------------------------------------------------------------------------
//引用做函数参数
void swap(int &a, int &b){
    int tmp = a;
    a = b;
    b = tmp;
}


int main() {
    int a = 10;
    int b = 20;
    swap(a,b);
    return 0;
}
------------------------------------------------------------------------------
//引用做返回值
int &test(){
    staic int a = 10;  //静态变量
    return a;
}

int main(){
    int &ret = test();
    printf("ret[%d]\n", ret);
    
    test() = 20;     //函数作为左值  
    printf("ret[%d]\n", ret);
    
    return 0;
}
------------------------------------------------------------------------------

 2. 友元

2.1.  什么是友元

        友元的目的就是让一个函数或者一个类，访问另一个类中私有成员。

        友元的关键字为 friend。

2.2.  友元使用方法

//全局函数做友元
class building
{
	friend void goodgay(building *building);

public:
	char m_sittingroot[30]; //客厅
private: 
	char m_bedroom[30];   //卧室
}

void goodgay(building *building){
    printf("bedroom = %s\n", building->m_bedroom);
}

int main(){
	building building;
    goodgay(&building);
    return 0;
}
---------------------------------------------------------------------------
//类 做友元
class building;
class goodgay
{
public:
	goodgay();
	void visit(); //参观
	building *building;
}

class building
{
	frind class goodgay; //goodgay类可以访问building的私有成员
public:
	building();

public:
	char m_sittingroot[30]; //客厅
private: 
	char m_bedroom[30];   //卧室
}

building::building()
{
    m_sittingroot = "客厅"; 
	m_bedroom = "卧室";
}

goodgay::goodgay() {
    building = new building();
}

void goodgay::visit()
{
    printf("bedroom = %s\n", building->m_bedroom);
}

int main(){
    goodgay gg;
    gg.visit();
}
---------------------------------------------------------------------------
//成员函数做 友元
class goodgay
{
public:
	goodgay();
	void visit(); //让visit函数可以访问building中的私有成员
	void visit2(); //让visit函数不可以访问building中的私有成员
	building *building;
}

class building
{
	friend void goodgay::visit(); //告诉编译器goodgay类下的成员函数是友元函数
public:
	building();

public:
	char m_sittingroot[30]; //客厅
private: 
	char m_bedroom[30];   //卧室
}

goodgay::goodgay() {
    building = new building();
}

building::building()
{
    m_sittingroot = "客厅"; 
	m_bedroom = "卧室";
}

void goodgay::visit()
{
    printf("bedroom = %s\n", building->m_bedroom);
}

int main(){
    goodgay gg;
    gg.visit();
}

3. 封装

3.1. 封装的作用

  1. 尽量使代码或者功能独立 (保证代码和功能独立性)。
  2. 封装，可以达到，对外提供接口，屏蔽数据，对内开放数据。
  3. c++的封装：class 封装的本质，在于将数据和行为，绑定在一起然后通过对象来完成操作。

 3.2. 封装的示例

1. public     公共权限
2. protected  保护权限：子类可以使用
3. private    私有权限：子类不可使用

---------------------------------------------------------------------
class student{
//访问权限
public:

//属性
char m_name[50];
int m_id;

//行为
void show_student() {
    printf("name[%s] id[%d]", m_name, m_id);
}

protected：
char m_car[50];

private:
char m_password[10];
};

int main(){
    //实例化对象
	student s1;
    strcyp(s1.m_name, "zhao");
    s1.id = 1;
    s1. show_student();
    
    return 0;
}

 4. 继承

4.1. 什么是继承

        继承是c++语言一个重要的机制，该机制自动地为一个类提供来自另一个类的操作和数据结构，这使得程序员只需在新类中定义已有的类中没有的成分来建立一个新类。

继承关系可分为3个级别：

  • public        公共权限
  • protected  保护权限：子类可以使用
  • private      私有权限：子类不可使用

 4.2. 继承的示例

// 基类 Animal
class Animal {
public:
    void eat() {
        std::cout << "Animal is eating\n";
    }

    void sleep() {
        std::cout << "Animal is sleeping\n";
    }
};

// 派生类 Dog，单继承自 Animal
class Dog : public Animal {
public:
    void bark() {
        std::cout << "Dog is barking\n";
    }
};

int main() {
     // 创建 Dog 对象
    Dog dog;
    dog.eat(); // 输出：Animal is eating
    dog.sleep(); // 输出：Animal is sleeping
    dog.bark(); // 输出：Dog is barking

    return 0;
}

4.3. 虚继承

        派生类可以重写基类的函数。

#include <iostream>

// 基类 Animal
class Animal {
public:
    void eat() {
        std::cout << "Animal is eating\n";
    }

    void sleep() {
        std::cout << "Animal is sleeping\n";
    }
};

// 派生类 Bird，虚继承自 Animal
class Bird : virtual public Animal {
public:
    // 重写 eat 方法
    void eat() {
        std::cout << "Bird is eating seeds\n";
    }

    // 重写 sleep 方法
    void sleep() {
        std::cout << "Bird is sleeping on a branch\n";
    }

    void chirp() {
        std::cout << "Bird is chirping\n";
    }
};

int main() {
    // 创建 Bird 对象
    Bird bird;
    bird.eat(); // 输出：Bird is eating seeds
    bird.sleep(); // 输出：Bird is sleeping on a branch
    bird.chirp(); // 输出：Bird is chirping
    return 0;
}

4.4. 纯虚函数

        基类中只需要声明纯虚函数，不需要实现。子类必须实现该函数。

#include <iostream>

// 基类 Animal
class Animal {
public:
    virtual void eat() = 0;

    virtual void sleep() = 0;
};

// 派生类 Bird，虚继承自 Animal
class Bird : public Animal {
public:
    // 重写 eat 方法
    void eat() {
        std::cout << "Bird is eating seeds\n";
    }

    // 重写 sleep 方法
    void sleep() {
        std::cout << "Bird is sleeping on a branch\n";
    }

    void chirp() {
        std::cout << "Bird is chirping\n";
    }
};

int main() {
    // 创建 Bird 对象
    Bird bird;
    bird.eat(); // 输出：Bird is eating seeds
    bird.sleep(); // 输出：Bird is sleeping on a branch
    bird.chirp(); // 输出：Bird is chirping
    return 0;
}

 5. 多态

5.1. 什么是多态

        多态的实现依赖于虚函数（virtual function）和动态绑定（dynamic binding）的机制。在 C++ 中，将基类中的方法声明为虚函数，子类可以选择性地重写这些虚函数。当通过基类的指针或引用调用虚函数时，程序在运行时会根据对象的实际类型动态地确定调用哪个版本的函数，这就是动态绑定。

优点：

  1. 代码重用：通过继承和多态，可以重用基类中的方法和行为，减少代码冗余。

  2. 可扩展性：通过添加新的子类，可以扩展系统的功能，而不需要修改现有的代码。

  3. 灵活性：同一个方法调用可以在不同对象上产生不同的行为，提高了代码的灵活性和可适应性。

  4. 简化接口：多态性使得程序可以通过统一的接口调用不同对象的方法，简化了接口设计。

5.2. 多态示例

//多态实现
//抽象计算器类
//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
class AbstractCalculator
{
public :

	virtual int getResult()
	{
		return 0;
	}

	int m_Num1;
	int m_Num2;
};

//加法计算器
class AddCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
};

//减法计算器
class SubCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 - m_Num2;
	}
};

//乘法计算器
class MulCalculator :public AbstractCalculator
{
public:
	int getResult()
	{
		return m_Num1 * m_Num2;
	}
};

int main() {

	//创建加法计算器
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  //用完了记得销毁

	//创建减法计算器
	abc = new SubCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;  

	//创建乘法计算器
	abc = new MulCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
	delete abc;

	return 0;

5.3. 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	//析构函数加上virtual关键字，变成虚析构函数
	//virtual ~Animal()
	//{
	//	cout << "Animal虚析构函数调用！" << endl;
	//}


	virtual ~Animal() = 0;
};

Animal::~Animal()
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;
};

void test01()
{
	Animal *animal = new Cat("Tom");
	animal->Speak();

	//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
	//怎么解决？给基类增加一个虚析构函数
	//虚析构函数就是用来解决通过父类指针释放子类对象
	delete animal;
}

int main() {
	test01();
	system("pause");
	return 0;
}

 6. 运算符重载

6.1. 运算符重载的作用

        对已有的运算符重新定义，赋予其另一种功能，以适应不同的数据类型。

6.2. + 运算符重载

#include <iostream>

class Counter {
private:
    int count;

public:
    Counter(int c = 0) : count(c) {}

    // 重载加法运算符 +
    Counter operator+(const Counter& other) {
        Counter result;
        result.count = this->count + other.count;
        return result;
    }

    // 获取计数器当前值
    int getCount() const {
        return count;
    }
};

int main() {
    Counter c1(5); // 创建计数器对象 c1，初始值为 5
    Counter c2(3); // 创建计数器对象 c2，初始值为 3

    Counter c3 = c1 + c2; // 使用重载的加法运算符将 c1 和 c2 相加，结果赋值给 c3

    std::cout << "c1 count: " << c1.getCount() << std::endl; // 输出 c1 的计数器值
    std::cout << "c2 count: " << c2.getCount() << std::endl; // 输出 c2 的计数器值
    std::cout << "c3 count: " << c3.getCount() << std::endl; // 输出 c3 的计数器值

    return 0;
}

 

搬运代码の外卖小哥
关注
专栏目录
C++入门基础(万字总结）（建议收藏！！！）
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++基础知识大全
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
C++基础入门
a577715979的博客
01-02 5598
C++入门
C++基础代码大全
QL857的博客
04-12 2万+
C++基础语言大全
C++基础知识点总结
深度学习 || 神经网络
02-07 1万+
自学c++过程中遇到的一些需要记忆的知识点,参考小甲鱼C++教程。
Qt学习之C++基础
RongLin02的博客
10-03 1万+
C++面向对象 类
C++入门基础
2021dragon的博客
05-22 1万+
文章目录什么是C++?C++的发展史C++关键字(C++98)命名空间C++中的输入和输出缺省参数函数重载引用内联函数auto关键字(C++11)基于范围的for循环(C++11)指针空值nullptr(C++11) 什么是C++?  C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象) 思想，支持面向对象的程序
C++入门基础（万字详解！！！）
热门推荐
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础知识
weixin_42397686的博客
06-12 2694
C++基础知识 一.C++与C语言的关系 C语言是C++的子集。C++是从C基础上发展而来的，C++程序能运行的环境也能运行C语言程序。 C面向对象；C++既支持面向对象，又支持面向过程。 二.数据类型 1. C语言中的数据类型 2. C++中新增的数据类型 示例： 三.C++随用随定义 示例： 四.输入/输出方式 1.C语言 scanf()函数与printf()函数 示例： 输入：scanf("%d %d",&x,&y); 输出：printf("%d %d\n",x,y);
C++基础语法：链表
baiyechangjiu的博客
08-19 8014
链表是物理存储单元上非连续的，非顺序的存储结构，链表是由一个个结点，通过指针来联系起来的，其中每个结点包含数据和指针： 或者我们采用另一张更加明显的图： 因为在C++语言中，当我们生成一个数组的时候，就要声明数组的长度，如此计算机便会在内存上开辟一个连续的不间断的内存空间来存储数据，因为存在着这样的一种可能，也就是数组所使用的内存空间之后的内存空间已经被使用，所以C++中一旦数组的大小明确了，就不能够再改变了。而且因为数组是存储一系列的同一类型的变量的集合，所以构成数组的每一个元素占用的内.
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础教程_完整版 - 副本.pdf
11-23
C++基础教程 本教程是对 C++语言的深入浅出的介绍，从基础知识到 ANSI-C++标准的最新功能，内容涵盖了从数组、类等基本概念到多态、模板等高级概念。本教程共分 6 章，每章分若干小节，每一小节都结合了可以工作的...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++基础与提高-王桂林-4rd.pdf
06-07
根据提供的文件信息，以下是...王桂林的《C++基础与提高》作为教材，能够为读者提供系统性的C++语言学习和深入讨论。通过学习这些知识，读者能够掌握C++语言的核心特性和编程技术，为进一步的软件开发打下坚实的基础。
由浅入深学C++基础进阶与必做300题 源程序
07-14
由浅入深学C++基础进阶与必做300题 源程序 解压后122M C++是近年广泛使用的程序设计语言，由C语言的基础上发展而来，实现 了由面向过程到面向对象的转变，全面支持面向对象的程序设计方法。C++ 语言在软件工业领域...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1035
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 629
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1090
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 398
【代码】求n的阶乘的相反数（c语言）
Visual C++教程：C++基础与上机安排
"本教学说明主要涵盖C++基础知识的教学，包括C++语言的入门概念、VC++编程环境的使用以及C++的基本语法要素。课程由武优西主讲，共60学时，其中30学时为理论讲解，30学时为实践操作。课程设有闭卷笔试，考试内容涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值