C++基础知识五

最新推荐文章于 2022-12-10 01:47:40 发布
最新推荐文章于 2022-12-10 01:47:40 发布
阅读量971 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296982/article/details/123941860
版权

一、智能指针
智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。标准库提供的两种智能指针的区别在于管理底层指针的方法不同，shared_ptr允许多个指针指向同一个对象，unique_ptr则“独占”所指向的对象。标准库还定义了一种名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中。

#include <iostream>
#include <memory>

using namespace std;

class Test
{
    public:
        Test()
        {
            cout<<"Test的构造函数"<<endl;
        }
        ~Test()
        {
            cout<<"Test的析构函数"<<endl;
        }

        void print()
        {
            cout<<"XXXX"<<endl;
        }
};

void f1()
{
    Test *t1 = new Test;
}

void f2()
{
    auto_ptr<Test> my_memory(new Test);
    my_memory->print();
}

int main(int argc, char const *argv[])
{
    f1();
    f2();
    return 0;
}

在这里插入图片描述

二、模板
2.1 概念：将函数的返回值和参数的类型参数化，也叫范型编程

2.2 函数模板

#include <iostream>
using namespace std;

int add(int x, int y)              //当模板函数和原函数同时存在时，优先调用原来的函数
{
    cout<<"int add(int x, int y)"<<endl;
    return x + y;
}

double add(double x, double y)
{
    cout<<"double add(double x, double y)"<<endl;
    return x + y;
}

template <typename T>          //声明一个虚拟类型T,模板函数不能做默认类型转换
T add(T x, T y)
{
    cout<<"template <typename T>"<<endl;
    return x + y;
}

template <typename T1, typename T2>
void print(T1 x, T2 y)
{
    cout<<x<<" "<<y<<endl;
}

int main(int argc, char const *argv[])
{
    cout<<add(1,2)<<endl;          //隐式调用
    cout<<add(1.11,  2.22)<<endl;
    cout<<add<int>(1,'a')<<endl;   //显示调用

    print(1,'a');

    return 0;
}

2.3 类模板
2.3.1 类模板的定义：类模板中定义的函数类型可以用在类声明和类实现中，类模板的目的同样是将数据类型参数化

#include <iostream>
using namespace std;

template <typename T, typename U>
class Test
{
    private:
        T a;
        U b;
    
    public:
        Test(T a, U b)
        {
            this->a = a;
            this->b = b;
        }
        void show()
        {
            cout<<a<<" "<<b<<endl;
        }
};


int main(int argc, char const *argv[])
{
    Test<int,char> t(1,'a');   //类模板创建时一定要显示调用   
    t.show();
     
    return 0;
}

在这里插入图片描述
类模板中的继承

#include <iostream>

using namespace std;

template <typename T, typename U>
class Parent
{
    protected:
        T a;
        U b;
    public:
        Parent(T a, U b)
        {
            this->a = a;
            this->b = b;
        }
        void show()
        {
            cout<<a<<" "<<b<<endl;
        }
};

class Child:public Parent<int, char>     //模板类派生普通类，继承的同时对基类实例化
{
    public:
        Child(int a, char b):Parent(a,b)
        {

        }
        void show()
        {
            cout<<a<<" "<<b<<endl;           
        }
};

template <typename T, typename U>
class Child2:public Parent<T,U>     //模板类派生模板类，继承的同时不需要对parent进行实例化
{
    private:
        U c;
    public:
        Child2(T a, U b, U c):Parent<T,U>(a,b)
        {
            this->c = c;
        }
        void show()
        {
            cout<<this->a<<" "<<this->b<<" "<<c<<endl;
        }
};

int main(int argc, char const *argv[])
{
    Child c1(1,'a');
    c1.show();

    Child2<int,double> c2(1,2.22,3.33);
    c2.show();
    return 0;
}

在这里插入图片描述
模板的声明

#include <iostream>

using namespace std;

template <typename T>    //类模板的声明的作用域仅对下一个函数或者类有效
class Test
{
    private:
        int a;
    
    public:
        Test(T a);
        void show();
        ~Test();
};

template <typename T>
Test<T>::Test(T a)  //Test<T>表示Test是模板类，不是普通类  
{
    this->a = a;
}

template <typename T>
void Test<T>::show()
{
    cout<<a<<endl;
}

template <typename T>
Test<T>::~Test()   
{
    cout<<"Test的析构函数"<<endl;
}

int main(int argc, char const *argv[])
{
    Test<int> t(1);
    t.show(); 
    return 0;
}

模板中的static关键字

#include <iostream>

using namespace std;

template <typename T>    //类模板的声明的作用域仅对下一个函数或者类有效
class Test
{
    private:
        int a;
    
    public:
        static int count;   //类外面初始化
        Test(T a);
        void show();
        ~Test();
};

template <typename T>
int Test<T>::count = 0;

template <typename T>
Test<T>::Test(T a)  //Test<T>表示Test是模板类，不是普通类  
{
    this->a = a;
}

template <typename T>
void Test<T>::show()
{
    cout<<a<<endl;
}

template <typename T>
Test<T>::~Test()   
{
    cout<<"Test的析构函数"<<endl;
}

int main(int argc, char const *argv[])
{
    Test<int> t1(1);
    Test<int> t2(1);
    Test<int> t3(1);
    Test<int> t4(1);
    Test<int> t5(1);
    Test<int> t6(1);
    Test<char> t7('a');
    Test<char> t8('b');
    Test<char> t9('c');
    Test<char> t10('d');

    cout<<Test<int>::count<<endl;
    cout<<Test<char>::count<<endl;
    
    return 0;
}

三、异常
3.1 什么是异常？
异常处理就是处理程序中的错误，所以错误就是指程序在运行期间的一些异常举动（栈溢出，读取文件不存在，野指针等）
3.2 异常的语法
抛出异常： throw关键词， 当执行throw关键词后，抛出异常
检测异常：try语句会检测异常
捕获异常：catch（异常类型 变量名）{处理语句}

#include <iostream>

using namespace std;

int Div(int x, int y)   //除
{
    if(0 == y)
    {
        throw 0; //抛出异常
    }
    return x / y;
}

int main(int argc, char const *argv[])
{
    int a, b;
    cin>>a>>b;

    try
    {
        cout<<Div(a,b)<<endl;
    }
    catch(int)
    {
        cout<<"zero excetion!"<<endl;
    }
    cout<<"hello world"<<endl;
    return 0;
}

3.3 异常的思想

#include <iostream>

using namespace std;

int Div(int x, int y)   //除
{
    if(0 == y)
    {
        throw 0; //抛出异常
    }
    
    return x / y;
}

int main(int argc, char const *argv[])
{
    int a, b;
    cin>>a>>b;

    try   //把可能异常的语句放在try语句中
    {
        cout<<Div(a,b)<<endl;
    }
    catch(int)
    {
        cout<<"zero excetion!"<<endl;
    }
    cout<<"hello world"<<endl;
    return 0;
}

3.4 异常的声明

#include <iostream>

using namespace std;

//int Div(int x, int y) throw(int , char);   //只能抛出整型或者字符型异常
//int Div(int x,int y) throw();  //不能抛出任何异常
int Div(int x,int y);   //可能抛出任何异常


int main(int argc, char const *argv[])
{
    int a, b; 
    cin>>a>>b;
    try
    {
        cout<<Div(a,b)<<endl;
    }
    catch(int)
    {
        cout<<"zero exception"<<endl;
    }
    catch(char)
    {
        cout<<"char exception"<<endl;
    }
    catch(double)
    {
        cout<<"double exception"<<endl;
    }
       
    cout<<"hello world"<<endl;
    return 0;
}
int Div(int x, int y)   //除
{
    if(0 == y)
    {
        throw 1.11; //抛出异常
    }
    
    return x / y;
}

3.5 异常的对象

#include <iostream>
using namespace std;

class Test
{
    public:
        Test()
        {
            cout<<"Test的构造函数"<<endl;
        }
        Test(const Test &is_obj)  //拷贝构造函数
        {
            cout<<"Test的拷贝构造函数"<<endl;
        }
        void print()
        {
            cout<<"Test exception"<<endl;
        }
        ~Test()
        {
            cout<<"Test的析构函数"<<endl;
        }
};

int Div(int x, int y)   //除
{
    if(0 == y)
    {
        //throw 1.11; //抛出异常
        throw new Test;
    }
    
    return x / y;
}

int main(int argc, char const *argv[])
{
    int a, b;
    cin>>a>>b;

    try
    {
        cout<<Div(a,b)<<endl;
    }
    catch(Test t)  //调用了拷贝构造函数
    {
        t.print();
    }
    catch(Test &t)   //引用
    {
        t.print();
    }
    catch(Test *t)    //Test *t = new Test;
    {
        t->print();
        delete t;   //需要手动释放
    }


    cout<<"hello world"<<endl;
    return 0;
}

3.6 标准异常库
execption基类提供一个函数：what(),用于返回错误信息
virtual const char * what() const throw();

//exception 基类提供了一个函数： what() 用于返回错误信息
//virtual const char * what()const throw();
#include <iostream>
#include <exception>

using namespace std;

class Test
{
    private:
        int id;
    public:
        Test(int i)
        {
            if(i < 0)
            {
                throw out_of_range("id不可以小于0");
            }

            id = i;
        }
};

int main(int argc, char const *argv[])
{
    try
    {
        Test t(-1);
    }
    catch(exception& e)
    {
        cout << e.what() << '\n';
    }
    
    return 0;
}

类型转换

C语言强制类型转换存在的问题
1.过于粗暴
2.难于定位

C++中的类型转换
static_cast 强制类型转换
限制条件：1.用于基本类型之间的转换，不能用于普通指针之间的转换
2.用于有继承关系的对象之间的转换和类指针之间的 转换
3.static_cast 是在编译期间进行转换的，无法在运行时检查类型，所以可能存在风险

#include <iostream>

using namespace std;

class Parent
{

};

class  Child:public Parent
{

};

int main(int argc, char const *argv[])
{
    int a = 1;
    char ch = 'a';
    a = static_cast<int>(ch);    //用于普通类型之间的转换
    cout<<a<<endl;

   // int *p = static_cast<int *>(&ch);  //不能用于普通指针之间的类型转换
    Parent p;
    Child c; 

    p = static_cast<Parent>(c);  //用于有继承关系的类对象之间的转换
   // cout<<p<<endl;

    Parent *p1 = static_cast<Parent *>(&c);    //用于类对象指针之间的转换  
    cout<<p1<<endl;
    return 0;

    
}

reinterpret_cast

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
    int a = 100;
    int b = 10;

    char *p = reinterpret_cast<char *>(&a);  //用于普通指针类型之间的转换（不安全）
    cout<<*(p+1)<<endl;

    int *q = reinterpret_cast<int *>(100);   //用于数字和指针之间的转换，很容易出现野指针

    *q = 1;
    
    return 0;
}

const_cast

#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    const int a = 1;   //常量
    int *p = const_cast<int *>(&a);
    *p = 100;
    cout<<a<<endl;

    const int &m = 1;   //常量
    int &n = const_cast<int &>(m);
    n = 100;
    cout<<m<<endl;
    cout<<n<<endl;
    return 0;
}

dynamic_cast

#include <iostream>
using namespace std;

class Parent
{
    public:
        virtual void show()
        {

        }
};

class Child: public Parent
{
    public:
        void show()
        {

        }
};

int main(int argc, char const *argv[])
{
    Child *c = new Child;
    delete c;

    c =  dynamic_cast<Child *>(new Parent);    //派生类指针指向基类对象（错误） 

    if(c == NULL)
    {
        cout<<"转换失败"<<endl;
    }
    else
    {
        cout<<"转换成功"<<endl;
        delete c;
    }

    return 0;
}
冬雪如春
关注
专栏目录
C++下静态数据成员受不受访问控制符的作用?
Zyong139064359的博客
03-27 1323
考试中遇到一道题,是静态数据成员受不受访问控制符的作用 有些疑惑,所以测试一下? #include <iostream> using namespace std; class test { public: static int i; test() {} void print(); protected: static int h; private: static int j...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++部分——C++面向对象（2）
读读书，敲敲代码，写写博客，思考思考人生。
03-12 299
1.有哪几种情况只能用intialization list,而不能用assignment（初始化列表和赋值的区别） 无论是在构造函数初始化列表中初始化成员，还是在构造函数体中对它们赋值，最终结果都是相同的。不同之处在于，使用构造函数初始化列表初始化数据成员，没有定义初始化列表的构造函数在构造函数体中对数据成员赋值。 对于const和reference类型成员变量，它们只能够被初始化而不能做赋值操
C++进阶学习----构造析构
deroy
03-20 374
微信公众号【编程学习基地】 目录构造函数构造函数的使用特点：构造函数的重载析构函数析构函数的使用特点关于delete[]构造析构顺序初始化列表 构造函数 为成员变量赋初值，分配资源，设置对象的初始状态 可以理解为类的初始化函数 构造函数的使用 #include<iostream> using namespace std; class STU { char* m_name; in...
c++编程之类和对象
boundlessAbjure的专栏
09-09 645
类的定义： 类是定义同一类所有对象的变量和方法的模型，是struct的延伸与拓展。类可以定义类变量和类方法。系统在第一次在程序中遇到一个类时为这个类建立它的所有类变量的拷贝，这个类的所有实例共享它的类变量。 对象的定义： class类型一旦被定义，它的实例变量（对象）就能被创建，并初始化，且能定义指针变量指向它。实例化的类就是对象。 在C++里，struct 和 class其实本质上是一样
自定义类的数组和指针数组是否调用构造和析构函数
qq_43217697的博客
04-09 3339
自定义类的数组和指针数组是否调用析构函数
C++基础知识总结
07-25
### C++基础知识总结 #### 一、C++数据和变量的类型及变量作用域 **1. 基本的内置类型** C++提供了一系列基本的内置数据类型，用于存储不同种类的数据。以下是一些常见的类型及其特点： - **布尔型 (`bool`)**：...
C++ 基础知识学习 C++ 基础知识.mk
最新发布
02-24
C++的基础知识是所有C++程序员必须掌握的，这包括但不限于语法、变量、数据类型、运算符、控制结构、函数、类与对象、模板和异常处理。 1. **基本语法**：C++的语法基于C语言，但增加了许多面向对象的特性。它遵循...
少儿编程C++初级基础知识点.zip
10-23
【少儿编程C++初级基础知识点】是针对初学者设计的一系列C++编程教学内容，旨在帮助孩子们建立起坚实的编程基础。这个压缩包包含了多个章节的源代码文件，涵盖了C++语言的基础概念和关键语法，让我们逐一解析这些...
析构函数和构造函数的隐式调用
youtime1212的博客
04-23 346
class Test {public: Test() {cout<<"default constructor"<<endl;} ~Test() {cout<<"default destructor"<<endl;} Test(int i):a(i){cout<<"from copy"<<endl;} Test(co...
C++入门知识一
IME的博客
05-27 98
学习目标： 掌握C++的基础知识 学习内容： 1.C++关键字 C++总计63个关键字：这里不需要知道每个关键字的含义，但需要了解C++的关键字具体都有什么。 asm do if return try continue auto double inline short typedef for bool dynamic_cast int signed typeid public break else long sizeof typename throw case enum mut
C++学习笔记-构造函数和析构函数
cj5785
04-03 1587
构造函数和析构函数是C++的重要组成部分，了解构造函数和析构函数有助于深入了解C++ 构造函数 构造函数产生的原因 在C++中，有时候需要在对象创建的时候初始化数据，如果采用普通函数的话，每次初始化都要调用函数，显得麻烦，另外，如果忘记初始化，那么其结果是未知的。 在C++中使用构造函数来完成初始化，使得对象在生成的时候就完成初始化动作 构造函数定义 C++中的类可以定义与类名相同的特殊成员函数...
c++调用函数完成x+y求和
starmultiple的博客
03-10 1927
#include<iostream> using namespace std; int add(int x, int y); int main() { int x, y,sum; ; cout << "please input x and y:\n "; cin >> x >> y; sum = add(x, y); cout << "x" << "+" << "y" << "=" << x
实验一：C++对C的扩充
xiaohuoban115的博客
03-16 2359
（1）输入以下程序，进行编译，观察编译情况，如果有错误，请修改程序，再进行编译，直到没有错误，然后进行连接和运行，分析运行结果（本题是《C++面向对象程序设计》第1章习题第9题）。 # include &amp;lt;iostream&amp;gt; using namespace std ; int main ( ) { int a , b ; c = add ( a , b ) cout &amp;lt;&amp;lt...
初识C++中的Class类（一），及自我见解。
weixin_54428357的博客
12-10 3229
初学者对C++中class类的总结与理解（一）
C++学习笔记22-类模板与数组类封装案例
拒绝任何因懒惰而生的省略号
03-19 1789
类模板22.0 前言22.1 类模板语法22.2 类模板和函数模板区别22.3 类模板中成员函数创建时机22.4 类模板对象做函数参数（有查看数据类型语法小知识）22.5 类模板与继承22.6 22.0 前言 之前已学习了函数模板的相关知识，接下来学习类模板的相关知识。 22.1 类模板语法 类模板作用： 建议一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表。 语法： template<typename T,typename U,typename V,...> //类中
c++中析构函数，构造函数和复制构造函数的理解
仗劍走天涯
11-13 224
// test.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <string> //#pragma warning(disable:4996) using namespace std; class test{ public: test() { cout <&...
csdn博客
u010472256的博客
09-25 365
常见笔/面试题-之构造函数和析构函数构造函数是用来初始化一个对象的，而析构函数的作用则是释放对象占用的空间。如果将虚函数、构造函数和析构函数结合起来会有怎么样的效果呢？ 构造函数可以是虚函数吗？答：构造函数不可以是虚函数！基于以下几点原因：（1）构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间动态确定实际类型的。在构建一个对象时，构造函数执行期间，对象未完全构建完成，编译器无法知
类的构造函数和析构函数
weixin_48256350的博客
04-23 978
构造函数 构造函数的作用：在定义对象的时候，（系统自动） 初始化对象中的信息. 构造函数的特点： 1.构造函数没有返回值 2.构造函数的名字必须与类名一致 3.构造函数不需要用户调用，在创建对象的时候会自动调用 4.构造函数的定义要在 公共区 5.构造函数可以重载 构造函数定义的语法： class 类名 { public: 类名() { } } 例子： class test { public: test(){cout <&l
C++基础知识练习题
C++基础知识点总结 从给定的文件中，我们可以总结出以下C++基础知识点： 1. 程序设计方法：自顶向下方法和自底向上方法。自顶向下方法将复杂的问题分解成许多小的问题来求解，而自底向上方法将已经求解的小问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值