c++入门

AI fish

已于 2024-02-21 16:11:01 修改

阅读量431

点赞数 11

文章标签： c++ 算法开发语言

于 2024-01-14 19:57:36 首次发布

本文链接：https://blog.csdn.net/2301_79569991/article/details/135585223

版权

1.框架

#include <iostream>
using namespace std;

int main()
{
   system("pause");

   return 0;

}

2.输出：

cout << "hello world" << endl;

cout << "a= " << a << endl;

3.常量两种表示方式：

1：#define 宏常量： #define 常量名常量值

通常在文件上方定义，表示一个常量

2.const修饰的变量：const 数据类型常量名 = 常量值

通常在变量定义前加关键字const，修饰变量为常量，不可修改

3.在创建一个变量或者常量时，必须要指定出对应的数据类型，否则无法给变量分配内存

4.1封装：

4.1.1：封装的意义：
封装是面向对象三大特性之一

1.将属性和行为作为一个整体，表现生活中的事物

2.将属性和行为加以权限控制

封装意义一：
在设计类的时候，属性和行为写在一起，表现事物语法：class 类名{ 访问权限：属性 / 行为}；

#include <iostream>  
using namespace std;  
const double PI = 3.14;  
  
class Circle {  
public: // 访问权限：公共  
	// 属性  
	int m_r; // 半径  
  
	// 行为  
	// 获取圆的周长  
	double calculateCircumference() {  
		// 获取圆的周长  
		return 2 * PI * m_r;  
	}  
};  
  
int main() {  
	// 通过圆类，创建圆的对象  
	Circle c1;  
	c1.m_r = 10;  
	cout << "圆的周长为：" << c1.calculateCircumference() << endl; // 修正cout的拼写错误  
	system("pause");  
      
	return 0;  
}

在给类中的属性进行赋值的时候，实际上有两种写法：
1.直接赋值

s1.setname = "张三"；

2.通过对象进行赋值（通过在类中创建函数来实现）

在类中加一个函数：

void setname(string name)
{  m_Name=name;
 };

在main函数中将数值输入这个函数

s1.setname("张三");

封装的意义二

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：
1.public 公共权限成员类内可以访问类外可以访问

2.protected 保护权限成员类内可以访问类外不可以访问儿子可以访问父亲中的保护内容

3.private 私有权限成员类内可以访问类外不可以访问儿子不可以访问父亲中的私有内容

4.1.2 struct与class的区别

struct 默认权限为公共

class默认权限为私有

4.1.3 成员属性设置为私有

优点一：可以自己控制读写权限

优点二：对于写权限，我们可以检测数据的有效性

4.2.对象的初始化和清理

4.2.1 ：构造函数与析构函数

c++利用了构造函数和析构函数来解决上述问题，这两个函数会被编译器自动调用，完成对象的初始化和清理工作。如果我们不提供这两个函数，编译器会提供，但编译器提供的构造函数和析构函数是空实现

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用

析构函数：主要用于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名（）{}
1.构造函数，没有返回值也不写void

2.函数名称与类名相同

3.构造函数可以有参数，因此可以发生重载

4.程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法： ~类名（）{}

1.析构函数，没有返回值也不写void

2.函数名称与类名相同，在名称前面加上 ~

3.析构函数不可以有参数，因此不可以发生重载

4.程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

4.2.2：构造函数的分类及调用

两种分类方式：
按参数：有参构造和无参构造（默认构造）

按类型：普通构造和拷贝构造


Person(int a)
{
	age = a;
}
//拷贝构造函数
Person(const Person &p)
{
	//将传入的人身上的所有属性，拷贝到我身上
	age =p.age;
}

三种调用方式：

1.括号法

Person p1；

//默认构造函数的调用

Person p2（10）；

//有参构造函数

Person p3（p2）；

//拷贝构造函数

注意：调用默认构造函数时不要加（），因为下面这行代码编译器会认为是一个函数的声明，不会认为在创建对象

Person p1（）；

2.显示法

Person p1；

Person p2 = Person(10)； //有参构造

Person p3 = Person(p2) ； //拷贝构造

Person（10）；

//匿名对象，特点：当前行执行结束时，系统会立即回收掉匿名对象

注意：不要利用拷贝构造函数初始化匿名对象，编译器会认为Person （p3）=== Person p3；

从而出现p3重复使用的报错

3.隐式转换法

Person p4 = 10；//相当于写了 Person p4 = Person（10）；有参构造

Person p5 = p4；拷贝构造

4.2.3：拷贝构造函数调用时机（*）

三种情况：

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值的方式返回局部对象

4.2.4：构造函数调用规则：

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

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝

构造函数拷贝规则如下：

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

4.2.5：深拷贝与浅拷贝（*）

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

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

4.6：继承

4.6.1：继承的语法及其定义:

1.继承语法

class 子类 : 继承方式父类

列如：class Java : public BasePage

{

}

继承的好处：可以减少重复的代码

2.继承的基本概念：

基类（父类）：被继承的类，提供派生类共享的属性和方法。
派生类（子类）：继承基类的类，可以添加新的属性和方法，也可以重写基类的方法。
继承关系：派生类与基类之间的“是”（is-a）关系。例如，如果有一个基类Animal和一个派生类Dog，那么可以说Dog是Animal。

派生类中的成员包括两大部分：
一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过来的表现其共性，而新增的成员表现其个性

4.6.2：继承方式

公有继承（public）：基类中的public和protected成员在派生类中保持原有访问级别，private成员不可见。
保护继承（protected）：基类中的public和protected成员在派生类中变为protected，private成员不可见。
私有继承（private）：基类中的所有成员在派生类中变为private。

4.6.3：继承中的对象模型

父类中的所有属性都会被继承给子类，私有成员只是被编译器隐藏了，但是还是会继承下去

4.6.4：继承中的构造和析构顺序

继承中先调用父类构造函数在调用子类构造函数，析构顺序与构造相反（穿靴脱帽）

4.6.5：继承同名成员的处理方法：

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域 s.Base::m_A
如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数，包括重载，如果想访问到父类中被隐藏的同名成员函数，需要加作用域

4.6.6：继承同名静态成员处理方式

静态成员和非静态成员出现同名处理方法一致

访问子类同名成员直接访问即可
访问父类同名成员需要加作用域

通过对象访问

cout << "Son 下 m_A = "<< s.m_A << endl;

cout << "Base 下 m_A = "<< s.Base::m_A << endl;

2.通过类名访问

cout << "Son 下 m_A = "<< Son::m_A << endl;

cout << "Base 下 m_A = "<< Son::Base::m_A << endl;

第一个：：代表通过类名方式访问第二个：：代表访问父类作用域下

4.6.7：多继承语法

多重继承：一个类可以从多个基类继承属性和方法。这可能导致二义性，即当多个基类含有同名成员时，派生类无法确定使用哪个。
虚继承：为了解决多重继承中的二义性问题，C++引入了虚继承。通过在派生类的继承列表中使用virtual关键字，可以确保基类子对象在派生类对象中只出现一次。

5. 方法的覆盖与隐藏

覆盖（Override）：派生类中有一个与基类虚函数签名完全相同的函数时，派生类的函数将覆盖基类的函数。这是多态性的基础。
隐藏（Hiding）：如果派生类中的函数与基类的非虚函数签名相同，那么派生类的函数将隐藏基类的函数，而不是覆盖它。这可能导致非预期的行为，因为基类的函数不会通过基类指针或引用被调用。

6. 抽象类和纯虚函数

纯虚函数：在基类中声明但没有实现的虚函数，通过在声明时使用= 0来指定。
抽象类：含有至少一个纯虚函数的类。抽象类不能被实例化，只能作为基类被继承。
接口类：一种只含有纯虚函数的抽象类，通常用于定义一组相关的操作。

7. 继承与组合

继承：表示“是”（is-a）关系，用于实现代码的重用和多态性。
组合：表示“有”（has-a）关系，通过在一个类中包含另一个类的对象来实现代码的重用。
选择：在设计类时，需要根据实际情况选择使用继承还是组合。通常，组合比继承更加灵活和安全。

1. 多态的基本概念

多态的定义：多态意味着“多种形态”。在面向对象编程中，多态允许你将派生类的对象当作基类的对象来处理。
实现多态的条件：多态的实现通常需要满足三个条件：存在继承关系、基类中存在虚函数、派生类对基类中的虚函数进行重写。

2. 虚函数

虚函数的定义：在基类中使用virtual关键字声明的成员函数。虚函数可以在派生类中被重写。
虚函数的实现：基类中的虚函数可以有实现（非纯虚函数），也可以没有实现（纯虚函数）。
虚函数的作用：虚函数是实现多态的关键。通过虚函数，程序可以在运行时确定调用哪个类的成员函数。
虚函数的调用：通过基类的指针或引用调用虚函数时，将调用实际指向对象的类的成员函数。

3. 纯虚函数和抽象类

纯虚函数的定义：在基类中声明但没有实现的虚函数，通过在声明时使用= 0来指定。
抽象类的定义：含有至少一个纯虚函数的类。抽象类不能被实例化，只能作为基类被继承。
抽象类的作用：抽象类用于定义接口，即一组相关的操作。派生类必须实现抽象类中的所有纯虚函数才能被实例化。
抽象类与多态的关系：抽象类是实现多态的一种手段。通过抽象类，可以定义一组相关的操作，而不需要实现它们。派生类可以根据需要实现这些操作，从而实现多态性。

4. 虚函数表（VTable）

虚函数表的定义：编译器为每个含有虚函数的类创建一个虚函数表（VTable）。虚函数表是一个存储虚函数地址的数组。
虚函数表的作用：虚函数表用于实现动态绑定。当通过基类的指针或引用调用虚函数时，程序会查找虚函数表以确定要调用的函数。
虚函数表的生成：编译器在编译时生成虚函数表，并将其与类的实例关联起来。每个类的实例都有一个指向虚函数表的指针。

5. 运行时类型识别（RTTI）

运行时类型识别的定义：RTTI是一种在运行时获取对象类型信息并进行类型转换的机制。
运行时类型识别的作用：通过RTTI，程序可以在运行时确定对象的实际类型，并进行安全的类型转换。
运行时类型识别的实现：C++提供了两个运算符来实现RTTI：typeid和dynamic_cast。typeid用于获取对象的类型信息，dynamic_cast用于进行安全的类型转换。

6. 多态的优缺点

优点：多态提高了代码的复用性和可扩展性，降低了代码的耦合度，使得程序更加灵活和易于维护。
缺点：多态增加了虚函数表的开销，可能导致程序的性能下降。此外，使用多态时需要小心处理对象的生命周期和内存管理问题，以避免出现内存泄漏或悬挂指针等问题。

. 模板的基本概念

模板定义：模板是C++中的一种泛型编程工具，它允许程序员在不知道具体数据类型的情况下编写代码。
模板类型：C++支持两种类型的模板——函数模板和类模板。

2. 函数模板

函数模板的声明：使用template关键字后跟尖括号中的类型参数列表来声明函数模板。

template <typename T>  
T add(T a, T b) {  
    return a + b;  
}

类型参数：在模板声明中，typename或class关键字用于指定类型参数。typename和class在此上下文中可互换使用。
模板实例化：当使用具体类型调用模板函数时，编译器会生成该类型的函数实例。

int result = add<int>(3, 4); // 显式实例化  
double dResult = add(3.0, 4.0); // 隐式实例化

函数模板特化：可以为特定类型提供模板的特化版本，以覆盖通用模板的行为。
类模板的声明：与函数模板类似，使用template关键字声明类模板。
3. 类模板

template <typename T>  
class MyClass {  
public:  
    MyClass(T value) : data(value) {}  
    T getData() const { return data; }  
private:  
    T data;  
};

MyClass<int> intObj(5); 
MyClass<std::string> strObj("Hello");

类模板的成员函数：类模板的成员函数可以在类外部定义，但需要保留模板参数列表。

template <typename T> 
T MyClass<T>::getData() const { 
return data; 
}

类模板的特化：与函数模板类似，可以为特定类型提供类模板的特化。
部分特化：类模板还支持部分特化，即只为模板参数的一部分提供具体类型。

4. 模板参数

类型参数：如上所述，typename或class用于指定类型参数。
非类型参数：模板还可以接受非类型参数，如整数或枚举值。
```
template <typename T, int Size> 
class Array { 
// ... 
};
```
默认模板参数：可以为模板参数提供默认值。
```
template <typename T = int> 
class MyClass { 
// ... 
};
```

5. 模板元编程

编译时计算：模板可以用于在编译时执行计算，这被称为模板元编程（TMP）。
模板元函数和元类：使用模板编写的在编译时执行的函数和类。
SFINAE：替换失败并非错误（Substitution Failure Is Not An Error）是模板元编程中的一个重要原则，允许在编译时根据类型特性选择不同的模板实例化。

6. 模板的优缺点

优点：
- 代码重用：模板允许编写类型无关的通用代码。
- 类型安全：编译器在编译时检查类型，提供类型安全。
- 性能：模板实例化生成的是具体类型的代码，通常比使用虚函数更高效。
缺点：
- 编译时间：模板实例化会增加编译时间。
- 代码膨胀：每个不同类型的实例化都会产生新的代码，可能导致代码膨胀。
- 模板错误：模板错误通常很难理解和调试。

1. STL容器的分类

STL容器大致可以分为以下几类：

序列容器：这些容器保持元素的插入顺序。主要包括vector、list、deque、array和forward_list。
关联容器：这些容器根据元素的键值对元素进行排序和访问。主要包括set、multiset、map和multimap，它们基于红黑树实现；以及unordered_set、unordered_multiset、unordered_map和unordered_multimap，它们基于哈希表实现。
容器适配器：这些不是真正的容器，而是基于其他容器提供的接口进行封装的适配器。主要包括stack、queue和priority_queue。