c++随笔-7

已于 2024-03-28 00:09:33 修改
阅读量663 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ visual studio 开发语言
于 2022-03-15 23:39:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/123515511
版权

函数模板

// 函数模板示例
template <typename T1, typename T2>
void Swap(T1 &a, T2 &b) {  // typename 也可使用 class 替换，推荐使用 typename
    a = a + b;
    b = a - b;
    a = a - b;
    std::cout << "template Swap a: " << a << "\tc: " << b << std::endl;
}

void Swap(int &a, int &b) {   // 重载函数模板 Swap 函数
    a = a + b;
    b = a - b;
    a = a - b;
    std::cout << "Swap a: " << a << "\tb: " << b << std::endl;
}

int main(int argc, char *argv[])
{
    int a = 10;
    int b = 20;
    short c = 'C';

    // 调用规则
    // 1. 编译器优先调用普通匹配函数
    // 2. 如果函数模板严格匹配，则调用函数模板
    // 3. 通过空模板实参限定编译器只通过模板匹配
    Swap(a, b);   // 有匹配的普通函数，调用普通函数(包括隐式转换)
    Swap(a, c);   // 函数模板进行函数调用时进行严格的类型匹配
    Swap<>(a, b); // 限定使用函数模板调用
    // Swap<short, short>(a, b);  // 参数类型和实际变量类型不匹配
    return 0;
}

输出结果：
Swap a: 20 b: 10
template Swap a: 67 c: 20
template Swap a: 10 c: 67

  • 模板包含函数模板和类模板，本质是类型参数化
  • 模板提供了一种将类型参数化的机制，减少代码的冗余
// 对应上边代码的汇编片段
        23 [1]	{
0x401604                  55                    push   %rbp
0x401605  <+    1>        48 89 e5              mov    %rsp,%rbp
0x401608  <+    4>        48 83 ec 30           sub    $0x30,%rsp
0x40160c  <+    8>        89 4d 10              mov    %ecx,0x10(%rbp)
0x40160f  <+   11>        48 89 55 18           mov    %rdx,0x18(%rbp)
0x401613  <+   15>        e8 b8 01 00 00        callq  0x4017d0 <__main>
        24 [1]	    int a = 10;
0x401618  <+   20>        c7 45 fc 0a 00 00 00  movl   $0xa,-0x4(%rbp)
        25 [1]	    int b = 20;
0x40161f  <+   27>        c7 45 f8 14 00 00 00  movl   $0x14,-0x8(%rbp)
        26 [1]	    short c = 'C';
0x401626  <+   34>        66 c7 45 f6 43 00     movw   $0x43,-0xa(%rbp)
        32 [1]	    Swap(a, b);   
0x40162c  <+   40>        48 8d 55 f8           lea    -0x8(%rbp),%rdx
0x401630  <+   44>        48 8d 45 fc           lea    -0x4(%rbp),%rax
0x401634  <+   48>        48 89 c1              mov    %rax,%rcx
0x401637  <+   51>        e8 24 ff ff ff        callq  0x401560 <Swap(int&, int&)>
        33 [1]	    Swap(a, c);  
0x40163c  <+   56>        48 8d 55 f6           lea    -0xa(%rbp),%rdx
0x401640  <+   60>        48 8d 45 fc           lea    -0x4(%rbp),%rax
0x401644  <+   64>        48 89 c1              mov    %rax,%rcx
0x401647  <+   67>        e8 24 18 00 00        callq  0x402e70 <Swap<int, short>(int&, short&)>
        34 [1]	    Swap<>(a, b); 
0x40164c  <+   72>        48 8d 55 f8           lea    -0x8(%rbp),%rdx
0x401650  <+   76>        48 8d 45 fc           lea    -0x4(%rbp),%rax
0x401654  <+   80>        48 89 c1              mov    %rax,%rcx
0x401657  <+   83>        e8 64 17 00 00        callq  0x402dc0 <Swap<int, int>(int&, int&)>
        36 [1]	    return 0;
0x40165c  <+   88>        b8 00 00 00 00        mov    $0x0,%eax
        37 [1]	}
0x401661  <+   93>        48 83 c4 30           add    $0x30,%rsp
0x401665  <+   97>        5d                    pop    %rbp
0x401666  <+   98>        c3                    retq
  • 重点看 callq，也就是函数调用，将参数类型泛化可知，泛化类型至少包含好几种参数类型，猪观理解是c++在编译阶段会创建和所包含类型相关的所有重载函数，而实际上c++对模板的处理采取二次编译，c++在初次编译阶段并未创建模板包含类型的重载函数，而仅仅只是对模板编写语法等分析，确保编译阶段通过，调用时c++对模板调用进行二次编译，且仅仅只创建生成具体的模板，不会创建其它类型

类模板

// 类模板示例
template <typename T>
class CBase {
public:
    void SetId(T id) {  // 类中实现模板类成员函数
        m_id = id;
    }
    void Print();
private:
    T m_id;
};

template <typename T>
void CBase<T>::Print() {  // 类外实现模板类成员函数，在同一个文件中的写法
    std::cout << "id : " << m_id << std::endl;
}

int main(int argc, char *argv[])
{
    CBase<int> base;  // 创建对象时必须指定类型
    base.SetId(10);
    base.Print();
    return 0;
}

输出结果：
id : 10

// 从模板类派生普通类
template <typename T>
class CBase {
public:
    void SetId(T id) {  // 类中实现模板类成员函数
        m_id = id;
    }
    void Print();
private:
    T m_id;
};

class CDerive : public CBase<int> {  // 类模板 继承
public:

};

template <typename T>
void CBase<T>::Print() {  // 类外实现模板类成员函数，在同一个文件中的写法
    std::cout << "id : " << m_id << std::endl;
}

int main(int argc, char *argv[])
{
    CDerive d;  // 创建对象时必须指定类型
    d.SetId(10);
    d.Print();
    return 0;
}

输出结果：
id : 10

// 从模板类派生模板类
template <typename T>
class CBase {
public:
    void SetId(T id) {  // 类中实现模板类成员函数
        m_id = id;
    }
    void Print();
private:
    T m_id;
};

template <typename T>
class CDerive : public CBase<T> {  // 类模板 继承
public:

};

template <typename T>
void CBase<T>::Print() {  // 类外实现模板类成员函数，在同一个文件中的写法
    std::cout << "id : " << m_id << std::endl;
}

int main(int argc, char *argv[])
{
    CDerive<int> d;  // 创建对象时必须指定类型
    d.SetId(10);
    d.Print();
    return 0;
}

输出结果：
id : 10

  • 模板类和函数模板一样，都是类型参数化，只不过类模板语法规则复杂
  • 模板类也可以继承，必须参数具体化，如果需要显式初始化，派生类需要调用基类构造函数，默认调用无参构造
  • 模板类可派生普通类，也可派生模板类
template <typename T>
class CBase {
public:
    void SetId(T id) {  // 类中实现模板类成员函数
        m_id = id;
    }
    void Print();

    template <typename>
    friend std::ostream &operator<< (std::ostream &os, CBase<T>& obj);
    T m_id;
    template <typename>
    friend void Report(CBase<int>& obj);
};

template <typename T>
void CBase<T>::Print() {  // 类外实现模板类成员函数，在同一个文件中的写法
    std::cout << "id : " << m_id << std::endl;
}

template <typename T>
std::ostream & operator<<(std::ostream &os, CBase<T>& obj) {
    os << "id : " << obj.m_id << std::endl;
    return os;
}

void Report(CBase<int>& obj) {
    std::cout << "id : " << obj.m_id << std::endl;
}

int main(int argc, char *argv[])
{
    CBase<int> base;  // 创建对象时必须指定类型
    base.SetId(10);
    base.Print();
    std::cout << base;
    Report(base);
    return 0;
}

输出结果：
id : 10
id : 10
id : 10

  • 友元函数使用在模板类中比较复杂，防止滥用友元
template <typename T>
class CBase {
public:
    static int m_id;
};

template <typename T>
int CBase<T>::m_id = 10;

int main(int argc, char *argv[])
{
    printf("int %#p\n", &CBase<int>::m_id);
    printf("double %#p\n", &CBase<double>::m_id);
    return 0;
}

输出结果：
int 0x408120
double 0x408110

  • 模板类使用 static 关键字时，不同的具体类有各自的 static 变量

异常

// 模拟抛出异常
void Exception(int i) {
    if (i == 10)
        throw "i == 10";
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (const char* e) {
        std::cout << e << std::endl;
    }
    return 0;
}

输出结果：
i == 10

  • 异常与函数独立互补，函数出错可抛出异常，异常捕获方式是严格基于类型匹配的
void Exception(int i) {
    if (i == 10)
        throw "i == 10";
}

void Throw() {
    try {
        Exception(10);
    } catch (const char* e) {
        std::cout << "throw e : " << e << std::endl;
        throw e;  // 继续抛出异常，不处理
    }
}

int main(int argc, char *argv[])
{
    try {
        Throw();
    } catch (const char* e) {
        std::cout << e << std::endl;
    }
    return 0;
}

输结果：
throw e : i == 10
i == 10

  • 异常抛出如果不处理程序中断，不处理异常可以继续向上抛出异常
// 栈解旋
class CBase {
public:
    CBase() {
        std::cout << "constructor" << std::endl;
    }
    ~CBase() {
        std::cout << "destructor" << std::endl;
    }
};
void Exception(int i) {
    CBase t;
    if (i == 10)
        throw "i == 10";
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (const char* e) {
        std::cout << e << std::endl;
    }
    return 0;
}

输出结果：
constructor
destructor
i == 10

  • 异常被抛出后，从进入 try 语句块起，到异常被抛出前，在这期间在栈上创建的所有对象都会被自动析构，析构顺序与构造顺序相反，这一过程称为栈解旋
// 异常接口
void Exception1(int i) {  // 默认可抛出任何异常
    if (i == 10)
        throw "i == 10";
}

void Exception2(int i) throw (int){  // 默认可抛出 int 异常
    if (i == 10)
        throw "i == 10";
}

void Exception3(int i) throw (){  // 默认不抛出任何异常
    if (i == 10)
        ;
}

int main(int argc, char *argv[])
{
    try {
//        Exception1(10);
//        Exception2(10);
        Exception3(10);
    } catch (...) {
        ;
    }
    return 0;
}

// 抛出异常类
class CException {};

void Exception(int i) {  
    if (i == 10)
        throw CException();  // 抛出异常类
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (CException e) {
        std::cout << "recv exception" << std::endl;
    }
    return 0;
}

// catch 接收异常类，普通变量方式
class CException {
public:
    CException() {
        std::cout << "CException()" << std::endl;
    }
    CException(const CException&) {
        std::cout << "CException(const CException&)" << std::endl;
    }
    ~CException() {
        std::cout << "~CException" << std::endl;
    }
};

void Exception(int i) {  // 默认可抛出任何异常
    if (i == 10)
        throw CException();    // 匿名对象
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (CException e) {   // 调用拷贝构造函数捕获抛出的异常类对象
        std::cout << "recv exception" << std::endl;
    }
    return 0;
}

输出结果：
CException()
CException(const CException&)
recv exception
~CException
~CException

// catch 接收异常类，引用方式
class CException {
public:
    CException() {
        std::cout << "CException()" << std::endl;
    }
    CException(const CException&) {
        std::cout << "CException(const CException&)" << std::endl;
    }
    ~CException() {
        std::cout << "~CException" << std::endl;
    }
};

void Exception(int i) {
    if (i == 10)
        throw CException();
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (const CException &e) {  // 匿名对象初始化引用，同一块空间
        std::cout << "recv exception" << std::endl;
    }
    return 0;
}

输出结果：
CException()
recv exception
~CException

// catch 接收异常类，指针方式
class CException {
public:
    CException() {
        std::cout << "CException()" << std::endl;
    }
    CException(const CException&) {
        std::cout << "CException(const CException&)" << std::endl;
    }
    ~CException() {
        std::cout << "~CException" << std::endl;
    }
};

void Exception(int i) {  // 默认可抛出任何异常
    if (i == 10)
        throw new CException(); // 申请堆内存
}

int main(int argc, char *argv[])
{
    try {
        Exception(10);
    } catch (const CException *e) {
        std::cout << "recv exception" << std::endl;
        delete e;  // 释放内存
    }
    return 0;
}

输出结果：
CException()
recv exception
~CException

文件操作

文件打开模式描述
ios::in只读
ios::out只写
ios::app从末尾追加
ios::binary二进制模式
ios::nocreate打开文件时，文件不存在，不创建文件
ios::noreplace打开文件时，文件不存在，则创建该文件
ios::trunc打开文件后，清空文件内容
ios::ate打开文件后，将文件指针位置移动到文件末尾
文件指针位置描述
ios::beg文件开始
ios::end文件末尾
ios::cur当前位置
#include <vector>
#include <string>
#include <fstream>
#include <iostream>

int main()
{
    // 读写文本文件
    std::ifstream in("hello.txt");
    std::ofstream out("out.txt", std::ios::app);
    if (!in.is_open()) {
        std::cout << "open file failed" << std::endl;
        return -1;
    }

    std::string temp;
    while(getline(in, temp)) {
        out << temp;
        out << std::endl;
    }

    in.close();
    out.close();
    return 0;
}

int main()
{
    // 写二进制文件
    std::ofstream out("out.dat", std::ios::binary);
    int num = 20;
    std::string str("Hello, World");
    out.write((char*)&num, sizeof(int));
    out.write(str.c_str(), str.size());
    out.close();

    // 读二进制文件
    std::ifstream in("out.dat", std::ios::binary);
    char buf[256] = {0};
    in.read((char*)&num, sizeof(int));
    in.read(buf, 256);
    std::cout << "int : " << num << std::endl;
    std::cout << "str : " << buf << std::endl;
    in.close();
    return 0;
}

输出结果：
int : 20
str : Hello, world

// 读取终端输入保存到文件
int main()
{
    std::ofstream out("out.txt", std::ios::app);
    std::string str;
    std::cin >> str;   // 会在空格处截断输入的内容
    out.write(str.c_str(), str.size());
    out.close();

    return 0;
}
  • 注意 std::cin 的用法，获取终端输入一行的内容可使用 getline 函数
无夜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++随笔-删除文件
CSDN_Anonymous的博客
06-07 4651
c++删除文件非常简单，只需remove("文件名")即可。 需要包含#include<windows.h>头文件。 一般情况下，remove
c++随笔-4
TimerSea的博客
03-10 898
本文介绍c++中define、typedef、const、引用、函数等相关知识
C++随笔-野指针
qq_34202054的博客
02-23 506
野指针 指向”垃圾“内存的指针可称为野指针。 指针变量没有初始化。 int* a; *a = 123; 编译结果： 已经不用的指针变量没有置为NULL。 指针的操作超出了变量的作用范围。
c++作业7
h911y的博客
06-05 249
一、最大公约和和最小公倍数 #include using namespace std; int f1(int x,int y); int f2(int x,int y); int main() { int x,y; cout << "请输入两个数：" << endl; cin>>x>>y; cout<<"这两个数的最大公约数是："<<f1(x,y)<<endl;
c++随笔
qq_29846883的博客
09-23 168
闲来无事写几个常用在面试中遇到的功能函数 1.剔除字符串其它与字符串无关符号,只保留字符和数字 void trim(std::string& s) { std::vector v; for (const auto& c : s) { if (isalnum(c)) { v.push_back(c); } } s.replace(s.begin(), s.
c++的一些随笔
01-28
一些随手笔记关于c++
c++计算eigen随笔(8)-数组、矩阵、向量（1）
01-20
在C++编程中，Eigen库是一个非常强大的工具，主要用于处理线性代数中的数组、矩阵和向量。本文将深入探讨Eigen库的基础知识，特别是如何使用它来定义和操作数组、矩阵。 首先，`typedef Matrix<> MyMatrixType` 和 ...
C++生成dump文件
03-22
在C++环境中，我们可以使用MiniDumpWriteDump函数来实现这个功能。现在，我们来详细讲解如何在C++ Windows工程中生成dump文件。 首先，我们需要包含相应的头文件。在`main.cpp`中，引入`windows.h`和`dbghelp.h`，...
c++计算eigen随笔(10)-数组、矩阵、向量（3）
01-06
默认构造函数总是可用的，从不执行任何动态内存分配，也从不初始化矩阵系数 Matrix3f a; MatrixXf b; 在这里, a是一个3×3矩阵，带有一个未初始化系数的普通浮点]数组， b是一个动态大小的矩阵，它当前的大小是0乘0...
C++ Primer 中文版（第 5 版）第一章——随笔（含练习）-源码
04-10
源码
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 399
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C++初探究（2）
Frenemy__的博客
07-09 1275
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 938
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 607
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
[c++] 可变参数模版
l23456789mmmmm的博客
07-07 483
可变参数模板是C++11及之后才开始使用,学校的老古董编译器不一定能用相信大家在刚入门c/c++时都接触过printf函数printf用于将数据格式化输出到屏幕上,它的参数非常有意思,可以支持任意数量,任意类型的多参数.而如果我们想实现类似这种的传参,在C里似乎并不支持c++11提出了可变模板参数来解决这一问题。
C++数据的高效传递--左值引用和右值引用
CHNIM的博客
07-05 378
右值引用主要用于实现移动语义和完美转发。左值引用和右值引用是C++中的两个重要概念。左值引用引用持久存在的对象，而右值引用引用临时对象。通过右值引用，C++实现了移动语义和完美转发，从而提高了程序的效率和灵活性。理解和正确使用它们，对于编写现代、高效的C++代码非常重要。
C-10 凸包
qq_46348003的博客
07-08 203
计算凸包的代码
【LinuxC语言】手撕Http协议之accept_request函数实现(一)
m0_62599305的博客
07-05 737
在计算机网络中，HTTP协议是一种常见的应用层协议，它定义了客户端和服务器之间如何进行数据交换。在这篇文章中，我们将深入探讨Linux C语言中实现HTTP协议的关键部分——accept_request函数。这个函数是服务器处理客户端请求的核心，它负责接收客户端的连接，读取HTTP请求，解析请求内容，并根据请求类型（GET或POST）调用相应的处理函数。我们将详细分析accept_request函数的实现，包括套接字的创建和绑定，监听客户端的连接，接收和解析HTTP请求，以及调用处理函数。
download c++ 2015-2019 redistributable
05-13
C++ 2015-2019可重发行组件是一款由微软公司提供的基于C++的软件开发包。当用户在计算机中运行需要使用到C++的应用程序或游戏时，需要下载和安装此软件以确保应用程序或游戏能够正常运行。同时，用户还可以通过安装...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值