C++笔记（体系结构与内核分析）

1.OOP面向对象编程 vs. GP泛型编程

  • OOP将data和method放在一起，目的是通过封装、继承、多态提高软件的可维护性和可扩展性
  • GP将data和method分开，可以将任何容器与任何算法结合使用，只要容器满足塞饭所需的迭代器类型

2.算法与仿函数的区别

bool strLonger(const string &s1, const string &s2)
{
	return s1.size() < s2.size();
}

// 算法
cout << "max of zoo and hello:" << max(string("zoo"), string("hello")) << endl;
// 仿函数
cout << "max of zoo and hello:" << max(string("zoo"), string("hello"), strLonger) << endl;

3.泛化、特化、偏特化

  • 泛化：支持广泛的数据类型和情况，而不是针对特定类型
  • 特化：为特定类型或一组类型提供特定的实现
#include <iostream>

// General template
template <typename T>
void print(T arg) {
    std::cout << "General print: " << arg << std::endl;
}

// Specialization for const char*
template <>
void print<const char*>(const char* arg) {
    std::cout << "Specialized print for const char*: " << arg << std::endl;
}

int main() {
    print(123);             // Uses general template
    print("Hello, world");  // Uses specialized template
}
  • 偏特化：针对特定类型组合提供优化的行为或特殊实现。完全特化需要指定模板的所有参数，偏特化只需指定部分参数，或对参数施加某些约束。
    • 第一种偏特化处理第二个模板参数为 int 的情况。
    • 第二种偏特化处理两个模板参数相同的情况。
#include <iostream>

// 基本模板
template <typename T, typename U>
class MyClass {
public:
    void print() {
        std::cout << "Base template\\n";
    }
};

// 偏特化：特化第二个类型为 int 的情况
template <typename T>
class MyClass<T, int> {
public:
    void print() {
        std::cout << "Partially specialized template for T and int\\n";
    }
};

// 偏特化：特化两个类型都为相同类型的情况
template <typename T>
class MyClass<T, T> {
public:
    void print() {
        std::cout << "Partially specialized template for T, T\\n";
    }
};

int main() {
    MyClass<double, double> myClass1;  // 会匹配 MyClass<T, T>
    MyClass<double, int> myClass2;     // 会匹配 MyClass<T, int>
    MyClass<double, char> myClass3;    // 会匹配基本模板 MyClass<T, U>

    myClass1.print();  // 输出: Partially specialized template for T, T
    myClass2.print();  // 输出: Partially specialized template for T and int
    myClass3.print();  // 输出: Base template
}

4.分配器allocates

分配器（allocators）是用来管理内存分配和回收的对象。

  • 在 VC6 中，operator new() 通常通过调用 malloc() 实现， malloc() 函数不仅会开辟用户请求的内存外，还会引入额外的内存开销：
void* operator new(size_t size) {
    void* p = malloc(size);
    if (p == 0) // 如果malloc失败，则抛出std::bad_alloc异常
        throw std::bad_alloc();
    return p;
}
  • 例如:当我们需要分配512个整型数据时
int *p = allocator<int>().allocate(512,(int *)0);
allocator<int>().deallocate(p,512);
  • 在 VC6 / BC++ / G++中，allocator 类都是使用 operator new 来分配内存，并使用 operator delete 来释放内存。其中，operator new() 通常通过调用 malloc() 实现开辟内存，operator delete() 通常通过调用 free() 实现回收内存：
// VC6 STL中容器对allocator的使用
template<class _Ty, class _A=allocator<_Ty>>  // 调用allocator类
class vector
{ ...
};

template <typename T>
class allocator {
public:
    typedef size_t    size_type; // size_t是一个无符合整型数据类型
    typedef ptrdiff_t difference_type;  // 表示同一个数组中任意两个元素之间的差异
    typedef T*        pointer;
    typedef T         value_type;

    pointer allocate(size_type n, const void* hint = 0) {
        return (pointer) (::operator new(n * sizeof(value_type)));
    }

    void deallocate(pointer p, size_type n) {
        ::operator delete(p);
    }
}
  • 在GCC2.9中
// VC6 STL中容器对allocator的使用
template<class T, class Alloc = alloc>  // 调用allocator类
class vector
{ ...
};

 

①内存池：由一系列内存块组成，每块预分配一定数量的内存。

②自由列表：每个固定大小的内存块都有自己的自由列表。

③大小分类：根据内存请求的大小被分类到不同的自由列表。

  • GCC4.9所附的标准库，其中**__pool_alloc就是GCC2.9中的alloc**

    // 使用方法
vector<string, __gnn_cxx::__pool_alloc<string>> vec;

5.容器的分类

 

6.容器list

G2.9版本：

template <class T, class Alloc = alloc>
class list{
protected:
		typeof __list_node<T> list_node;  // 1号代码块
public:
		typeof list_node* link_type;
		typeof __list_iterator<T,T&,T*> iterator;  // 2号代码块
protected:
		link_type node;
}

// 1号代码块
template <class T>
struct __list_node {
		void* prev;
		void* next;
		T data;
};

// 2号代码块
template <class T,class Ref,class Ptr>
struct __list_iterator{
		typedef bidirectional_iterator_tag iterator_category;  // (1)
		typedef T  value_type;  // (2)
		typedef Ptr pointer;  // (3)
		typedef Ref reference;  // (4)
		typedef ptrdiff_t difference_type;  // (5)
		typedef __list_node<T> list_node;
		typedef list_node* list_type;
		typedef __list_iterator<T,Ref,Ptr> self;
		
		link_type node;
		reference operator*() const{ return (*node).data; }  // 返回引用
		pointer operator->() const{ return &(operator *());}  // 返回指针。获得该对象的内存地址，即一个指向该对象的指针
		self& operator++()   // i++
		{ node = (link_type) ((*node).next); return *this; // 返回自身的引用}
		// (*node).next是一个 __list_node<T>* 类型的值，加上(list_type)是显式类型转换
	  // (*node).next 等价于 node->next 等价于 (&(*node))->next;
	  // node只是一个迭代器的指针，不是迭代器本身
	  // self&表示返回迭代器的引用
		self operator++(int)   // ++i
		{ self tmp = *this; ++*this; return tmp;}
};
  • 前缀递增 (operator++()) 将迭代器向前移动到下一个元素
  • 后缀递增 (operator++(int)) 返回迭代器的一个临时副本（在递增前的状态），然后再递增迭代器。
  • 内置 -> 操作符 用于直接从指针访问对象成员。
  • 重载的 operator->() 提供了一种方式，通过迭代器对象模拟原生指针的行为，允许通过迭代器间接访问对象成员。
  • (*node).next等价于node->next 等价于 (&(*node))->next

G4.9版本:

template<typename _Tp, typename _Alloc=std::allocator<_Tp>>
class list:protected_List_base<_Tp,_Alloc>
{
public:typedef _List_iterator<_Tp> iterator;
}
  • template<typename _Tp, typename _Alloc = std::allocator<_Tp>>
    • 这是一个类模板，接受两个模板参数。
    • _Tp 表示列表中要存储的数据类型。
    • _Alloc 是分配器类型，用于控制链表中元素的内存分配。这个参数有一个默认值，即 std::allocator<_Tp>，这是 C++ 标准库提供的一种通用内存分配器。
  • : protected _List_base<_Tp, _Alloc>
    • list 类从 _List_base 类继承而来，使用保护（protected）继承。这意味着 _List_base 中的公共和保护成员在 list 类中将变为保护成员。
    • _List_base 是一个实现链表基础功能的类
template<typename _Tp>
struct _List_iterator
{
		typedef _Tp* pointer;
		typedef _Tp& reference;
		...
};

// 自身类型的指针使得可以从任何一个节点开始
// 沿着链表向前或向后移动，这对于双向遍历和双向操作非常重要。
struct _List_node_base
{
		_List_node_base* _M_next;
		_List_node_base* _M_prev;
};

template<typename _Tp>
struct _List_node:public _List_node_base
{
		_Tp _M_data;
};

7.Iterator必须提供5中associated types

算法提问：

template<typename T>
incline void
algorithm(T first, T last)  // 迭代器
{
		...
		T::iterator_category
		T::value_type
		T::pointer
		T::reference
		T::difference_type
		...
};

迭代器回答：

template <class T,class Ref,class Ptr>
struct __list_iterator{
		typedef bidirectional_iterator_tag iterator_category;  // (1)
		typedef T  value_type;  // (2)
		typedef Ptr pointer;  // (3)
		typedef Ref reference;  // (4)
		typedef ptrdiff_t difference_type;  // (5)
	...
};

8. iterator_traits 类型萃取

但当我们向算法中传入的是指针，而不是迭代器时，就需要用到traits。也就是说，iterator_traits 为所有类型的迭代器（包括原生指针）提供统一的方式来访问迭代器的属性，是在 <iterator> 头文件中定义的。

作用：

std::iterator_traits 模板用于提取迭代器相关的类型信息。

举例:

#include<iostream>
#include<iterator>
#include<vector>

template<typename Iterator>
void print_vector(Iterator first, Iterator last)
{
		// using关键字用来定义类型的别名
		// typename关键字告诉编译器这是一个依赖于模版参数Iterator的类型，而不是变量
		using ValueType = typename iterator_traits<Iterator>::value_type;
}

int main()
{
		vector<int> v = {1,2,3,4,5};
		print_vector(v.begin(), v.end());
}

// 当Iterator是一个类时
template<class Iterator>
struct iterator_traits
{
		typedef typename Iterator::value_type value_type;
};

// 两种偏特化情况
// 当Iterator是一个普通指针时
// 如int*,那么T为int，得到value_type就被定义为“int”
template<class T>
struct iterator_traits<T*>
{
		typedef T value_type;
};

// 当Iterator是一个常量指针（指针的指向可以修改，指针指向的值不能修改)
template<class T>
struct iterator_traits<const T*>
{
		typedef T value_type;
};
  • Iterator若是int*，ValueType 就是 int
  • Iterator若是const int*，ValueType 还是 int
  • 因为如果 ValueType 是 const int，后续再使用ValueType创建其他容器时，就会受到限制。因为标准库中的容器（如 std::vector）不能存储常量类型的元素,它们需要能被赋值和移动。

完整的iterator_traits:

template<class Iterator>
struct iterator_traits
{
		typedef typename Iterator::iterator_category iterator_category;
		typedef typename Iterator::value_type value_type;
		typedef typename Iterator::pointer iterator_category;
		typedef typename Iterator::reference reference;
		typedef typename Iterator::difference_type difference_type;
};

template<class T>
struct iterator_traits<T*>
{
		typedef random_access_iterator_tag iterator_category;
		typedef T value_type;
		typedef ptrdiff_t difference_type;
		typedef T* pointer;
		typedef T& reference;
};

template<class T>
struct iterator_traits<const T*>
{
		typedef random_access_iterator_tag iterator_category;
		typedef T value_type;
		typedef ptrdiff_t difference_type;
		typedef const T* pointer;
		typedef const T& reference;
};

9.容器vector

定义：

template <class T, class Alloc = std::allocator<T>>
class vector
{
public:
		typedef T value_type;
		typedef T* pointer;
		typedef &T reference;
		typedef size_t size_type;
protected:
		iterator **start**;
		iterator **finish**;
		iterator **end_of_range**;
		Allocator alloc;
public:
		iterator begin() { return **start**;}
		iterator end() { return **finish**;}
		size_type size const { return size_type(end() - start());}
		size_type capacity() const
		{ return size_type(**end_of_storage** - begin());}
		bool empty() const { return begin() == end();}
		reference operator[](size_type n}
		{return *(begin()+n);
		referebce front() {return *begin();}
		reference back() {return *(end()-1);}
};

push_back操作源码：

template <class T, class Alloc=std::allocator<T>>
void push_back(const T& value)
{
	if(finish == end_of_storage)  // 原始空间不足
	{
		 size_type old_size = size();
		 // old_size == 0:当前vector中没有任何元素，新分配的存储空间至少有一个元素的容量
		 // old_size != 0:分配新的容量将是当前大小的两倍, 称为指数增长
		 size_type new_capacity = old_size == 0 ? 1 : 2 * old_size;
		 iterator new_start = alloc.allocator(new_capacity);
		 iterator new_finsih = new_start;
		 try{
					// 将原数据移动到新空间
				 for(iterator old_iter = start; old_iter != finish; )
				 {
						 alloc.construct(new_finish++, *old_iter);
						 alloc.destroy(old_iter++);
				 }
				 // 添加新元素
				 alloc.construct(new_finish++, value);
		 }catch(...){
				 // 如果构造失败，释放已分配的内存
				 for(iterator it=new_start; it!=new_finish; ++it)
				 {
						 alloc.destory(it);
				 }
				 alloc.deallocate(new_start, new_capacity);
				 throw;  // 重新抛出当前异常
			}
			// 释放旧空间
      if (start) {
          alloc.deallocate(start, end_of_storage - start);
      }
      // 更新指针
      start = new_start;
      finish = new_finish;
      end_of_storage = start + new_capacity;
  } 
  else 
  {
      alloc.construct(finish++, value); // 有足够空间，直接构造新元素
  }
}

vector的迭代器iterator：

template <class T, class Alloc = alloc>
class vector
{
public:
		typedef T value_type;
		typedef T* iterator;
};

// 调用方法
vectot<int> v;
vector<int>::iterator it = v.begin();

10.容器deque

 


// BufSize是指缓冲区buffer的长度
template<class T,class Alloc = alloc, size_t BufSize=0>
class deque
{
public:
		typedef T value_type;
		typedef size_t size_type;
		typedef __deque_iterator<T,T&,T*,BufSiz> iterator;
protected:
		typedef T** map_pointer;  // 指向指针数组的指针
protected:
		iterator start;
		iterator finish;
		map_point map;  // 指向指针数组的指针，每一个都指向一个缓冲区
		size_type map_size;
public:
		iterator begin() {return start;}
		iterator end() {return finish;}
		size_type size() {return finish - start;}
		...
};

deque的迭代器iterator：

template<class T, class Ref, class Ptr, size_t BufSize>
struct __deque_iterator
{
		typedef random_access_iterator_tag iterator_category;
		typedef T value_type;
		typedef Ref reference; // T&
		typedef Ptr pointer; // T*
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;
		typedef T** map_pointer;
		typedef __deque_iterator<T,Ref,Ptr,BufSiz> self;
		
		T* **cur**;
		T* **first**;
		T* **last**;
		map_point **node**;
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/618382.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

OGG几何内核-网格化的改进

OGG几何内核-网格化的改进

OGG社区于4月19日发布了OGG 1.0 preview版本。相对于OCCT 7.7.0有很多改进&#xff0c;目前在持续研究中。最近测试了一下网格化&#xff0c;确实有很好的改进。对比展示如下&#xff1a; 几何内核&#xff1a; OGG 1.0 preview 几何内核&#xff1a;OCCT 7.7.0 采用OCCT几何内…
阅读更多...
IT项目管理-小题计算【太原理工大学】

IT项目管理-小题计算【太原理工大学】

1.合同总价问题 问承包商的利润是&#xff1f; 实际利润目标利润&#xff08;目标成本-实际成本&#xff09;*卖方分担比例 解&#xff1a;10 000&#xff08;100 000 - 90 000&#xff09;* 0.2 12 000&#xff08;元&#xff09; 实际成本有时也写作最终成本&#xff0c;问承…
阅读更多...
cmu15445 2023fall project3 详细过程（下）QUERY EXECUTION

cmu15445 2023fall project3 详细过程（下）QUERY EXECUTION

QUERY EXECUTION task3/task4 Task #3 - HashJoin Executor and Optimization1、HashJoin1.1 思路1.2 代码 2 NestedLoopJoin优化为HashJoin2.1 思路2.2 代码 Task #4 Sort Limit Executors Top-N Optimization Window Functions1、Sort1.1 思路1.2 代码 2、Limit Executors2…
阅读更多...
Linux与Windows互传文件【笔记】

Linux与Windows互传文件【笔记】

Linux与Windows互传文件【笔记】 前言前言推荐Linux与Windows互传文件首先确保Windows安装ssh如何传送文件问题 最后 前言 这是陈旧已久的草稿2023-05-10 00:01:24 这个是准备把计组课程华为智能计组的&#xff0c;传输文件。 最后发现&#xff0c;好像没有实现了。 现在202…
阅读更多...
Java 守护线程 ( Daemon Thread )详解

Java 守护线程 ( Daemon Thread )详解

在Java中&#xff0c;线程分为两类&#xff1a;用户线程(User Thread)和守护线程(Daemon Thread)。守护线程是后台线程&#xff0c;主要服务于用户线程&#xff0c;当所有的用户线程结束时&#xff0c;守护线程也会自动结束&#xff0c;JVM会随之退出。守护线程的一个典型例子是…
阅读更多...
pikachu靶场（xss通关教程）

pikachu靶场（xss通关教程）

&#xff08;注&#xff1a;若复制注入代码攻击无效&#xff0c;请手动输入注入语句&#xff0c;在英文输入法下&#xff09; 反射型xss(get型) 1.打开网站 发现有个框&#xff0c;然后我们在框中输入一个“1”进行测试&#xff0c; 可以看到提交的数据在url处有显示&#xf…
阅读更多...
AI跟踪报道第41期-新加坡内哥谈技术-本周AI新闻：本周Al新闻: 准备好了吗？事情即将変得瘋狂

AI跟踪报道第41期-新加坡内哥谈技术-本周AI新闻：本周Al新闻: 准备好了吗？事情即将変得瘋狂

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
Oracle 删除表中的列

Oracle 删除表中的列

Oracle 删除表中的列 CONN SCOTT/TIGER DROP TABLE T1; create table t1 as select * from emp; insert into t1 select * from t1; / / --到6000行&#xff0c;构造一个实验用大表T1。 COMMIT; select EXTENT_ID,FILE_ID,BLOCK_ID,BLOCKS from dba_extents where SEGMENT_…
阅读更多...
【Qt 学习笔记】Qt常用控件 | 布局管理器 | 水平布局Horizontal Layout

【Qt 学习笔记】Qt常用控件 | 布局管理器 | 水平布局Horizontal Layout

博客主页&#xff1a;Duck Bro 博客主页系列专栏&#xff1a;Qt 专栏关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ Qt常用控件 | 布局管理器 | 水平布局Horizontal Layout 文章编号&…
阅读更多...
异常处理/CC++ 中 assert 断言 应用实践和注意事项

异常处理/CC++ 中 assert 断言 应用实践和注意事项

文章目录 概述assert 本质浅析Release版本下的assert是否生效默认设置下 QtCreator环境 assert 过程默认配置下 VS环境 assert 过程配置VS发布模式下的断言生效VS环境Release版本的UI程序Release下请当我不生效 请勿滥用assert导致逻辑错误再强调不要在assert内执行逻辑功能怎敢…
阅读更多...
react18【系列实用教程】useContext —— Context 机制实现越层组件传值 （2024最新版）

react18【系列实用教程】useContext —— Context 机制实现越层组件传值 （2024最新版）

什么是 Context 机制&#xff1f; Context 机制是 react 实现外层组件向内层组件传值的一种方案&#xff0c;父组件可以向其内部的任一组件传值&#xff0c;无论是子组件还是孙组件或更深层次的组件。 实现步骤 1.使用createContext方法创建一个上下文对象 Ctx 2.在顶层组件中通…
阅读更多...
轮转数组 与 消失的数字

轮转数组 与 消失的数字

轮转数组 思路一 创建一个新内存空间&#xff0c;将需轮转的数依次放入&#xff0c;之后在把其它数放入 代码&#xff1a; void rotate(int* nums, int numsSize, int k) {k k % numsSize;// 确定有效的旋转次数if(k 0)return;int* newnums (int*)malloc(sizeof(int) * nu…
阅读更多...
An 2024下载

An 2024下载

An2024下载&#xff1a; 百度网盘下载https://pan.baidu.com/s/1cQQCFL16OUY1G6uQWgDbSg?pwdSIMS Adobe Animate 2024&#xff0c;作为Flash技术的进化顶点&#xff0c;是Adobe匠心打造的动画与交互内容创作的旗舰软件。这款工具赋予设计师与开发者前所未有的创意自由&#x…
阅读更多...
设计模式-结构型-桥接模式-Bridge

设计模式-结构型-桥接模式-Bridge

桥接模式可以减少类的创建 矩阵类 public class Matrix {private String fileName;public Matrix(String fileName) {this.fileName fileName;}public String getFileName() {return fileName;} } 图片抽象类 public abstract class Image {protected ImageImp imp;public …
阅读更多...
vivado Kintex UltraScale 配置存储器器件

vivado Kintex UltraScale 配置存储器器件

Kintex UltraScale 配置存储器器件 下表所示闪存器件支持通过 Vivado 软件对 Kintex UltraScale 器件执行擦除、空白检查、编程和验证等配置操作。 本附录中的表格所列赛灵思系列非易失性存储器将不断保持更新 &#xff0c; 并支持通过 Vivado 软件对其中所列非易失性存…
阅读更多...
深入解析MySQL中的事务（下）

深入解析MySQL中的事务（下）

MySQL事务管理 3. 隔离性&#xff08;Isolation&#xff09;查看和设置隔离级别隔离级别作用域区别与解析 四种隔离级别解析小结 4. 一致性&#xff08;Consistency&#xff09;如何保持一致性 5.“保持原子性、隔离性、持久性就能保证一致性”的理解&#xff1a; 四、如何理解…
阅读更多...
图论专题训练

图论专题训练

leecode 547 并查集 class Solution { public:int findCircleNum(vector<vector<int>>& isConnected) {ini();int len isConnected.size();for(int i0;i<len;i){for(int j0;j<len;j)if(isConnected[i][j]){unio(i,j);}}int ans 0;for(int i0;i<len;…
阅读更多...
自动驾驶技术与传感器数据处理

自动驾驶技术与传感器数据处理

目录 自动驾驶总体架构 感知系统 决策系统 定位系统 ​计算平台​ 仿真平台​ 自动驾驶公开数据集 激光点云 点云表征方式 1) 原始点云 2) 三维点云体素化 3)深度图 4)鸟瞰图 点云检测障碍物的步骤 PCL点云库 车载毫米波雷达 车载相机 设备标定 自动驾驶…
阅读更多...
python选修课期末考试复习

python选修课期末考试复习

目录 记住输出小数的格式文件条件判断随想循环小星星计算金额猜数字折纸 函数找最大值 基础知识总结 记住输出小数的格式 输出a&#xff0c;保留两位小数 %.2f%a打开文件有点儿难&#xff0c;多记几遍格式吧 文件的格式后面有冒号&#xff0c;谨慎一点&#xff0c;都用双引号…
阅读更多...
花了24小时做的采购、库存、进销存excel模板，真心好用，免费分享

花了24小时做的采购、库存、进销存excel模板，真心好用，免费分享

花了24小时做的采购、库存、进销存excel模板&#xff0c;真心好用 在企业的日常运营中&#xff0c;进销存管理是一项至关重要的任务。它不仅涉及到商品的采购、销售和库存管理&#xff0c;还直接影响到企业的财务状况和市场竞争力。为了提高管理效率&#xff0c;许多企业选择使…
阅读更多...
最新文章

Copyright @ 2022~2023