C++深度解析教程笔记11ok-智能指针，逻辑&逗号&自增操作符，类型转换函数

于 2024-07-16 21:28:05 发布
阅读量622 收藏 2
点赞数 13
文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35429166/article/details/138866826
版权

C++深度解析教程笔记11

本文学习自狄泰软件学院 唐佐林老师的 C++深度解析教程，图片全部来源于课程PPT，仅用于个人学习记录

第37课 - 智能指针分析

在这里插入图片描述

实验-内存未释放并优化

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int i;
public:
    Test(int i)//带参数的构造函数
    {
        this->i = i;
		cout<<"Test();"<<endl;
    }
    int value()
    {
        return i;
    }
    ~Test()//析构函数
    {
		cout<<"~Test();"<<endl;
    }
};
//优化，定义一个指针类，成员变量类型为Test*
class pointer
{
	 Test * mp;
public:
	pointer(Test* p=NULL)//构造函数默认值为NULL
	{
		mp=p;
	
	}
	Test * operator ->()
	{
	return mp;
	}
	Test  operator *()
	{
	return *mp;
	}
	~pointer()
	{
	delete mp;
	
	}
	


};

int main()
{
    for(int i=0; i<5; i++)
    {
        //Test* p = new Test(i);
//优化
       pointer p = new Test(i);
        
        cout << p->value() << endl;
        
    
    }
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述

实验-指针作为类

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int i;
public:
    Test(int i)
    {
        cout << "Test(int i)" << endl;
        this->i = i;
    }
    int value()
    {
        return i;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
};

class Pointer
{
    Test* mp;
public:
    Pointer(Test* p = NULL)
    {
        mp = p;
    }
    Pointer(const Pointer& obj)
    {
        mp = obj.mp;
        const_cast<Pointer&>(obj).mp = NULL;
    }
    Pointer& operator = (const Pointer& obj)
    {
        if( this != &obj )
        {
            delete mp;
            mp = obj.mp;
            const_cast<Pointer&>(obj).mp = NULL;
        }
        
        return *this;
    }
    Test* operator -> ()
    {
        return mp;
    }
    Test& operator * ()
    {
        return *mp;
    }
    bool isNull()
    {
        return (mp == NULL);
    }
    ~Pointer()
    {
        delete mp;
    }
};

int main()
{
    Pointer p1 = new Test(0);
    
    cout << p1->value() << endl;
    
    Pointer p2 = p1;
    
    cout << p1.isNull() << endl;
    
    cout << p2->value() << endl;
    
    return 0;
}
/*
Test(int i)
0
1
0
~Test()

*/

智能指针的使用军规
只能用来指向堆空间中的对象或者变量

小结

指针特征操作符（->和*）可以被重载重载
指针特征符能够使用对象代替指针
智能指针只能用于指向堆空间中的内存
智能指针的意义在于最大程度的避免内存问题

第38课 - 逻辑操作符的陷阱

逻辑运算符的原生语义
一操作数只有两种值（true和false）
一逻辑表达式不用完全计算就能确定最终值一最终结果只能是true或者false

实验-逻辑与或

#include <iostream>
#include <string>

using namespace std;

int func(int i)
{
    cout << "int func(int i) : i = " << i << endl;
    
    return i;
}

int main()
{
    if( func(0) && func(1) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    cout << endl;
    
    if( func(0) || func(1) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    return 0;
}
/*
int func(int i) : i = 0
Result is false!

int func(int i) : i = 0
int func(int i) : i = 1
Result is true!
*/

逻辑操作符可以重载吗？重载逻辑操作符有什么意义？

实验-重载与或

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int v)
    {
        mValue = v;
    }
    int value() const
    {
        return mValue;
    }
};

bool operator && (const Test& l, const Test& r)
{
    return l.value() && r.value();
}

bool operator || (const Test& l, const Test& r)
{
    return l.value() || r.value();
}

Test func(Test i)
{
    cout << "Test func(Test i) : i.value() = " << i.value() << endl;
    
    return i;
}

int main()
{
    Test t0(0);
    Test t1(1);
    
    if( operator && (func(t0) , func(t1)))
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    cout << endl;

     if( func(t0) && func(t1) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    cout << endl;

    if( operator ||(func(t0), func(t1)  ))
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    cout << endl;
    
    if( func(1) || func(0) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }
    
    return 0;
}
/*
Test func(Test i) : i.value() = 1
Test func(Test i) : i.value() = 0
Result is false!

Test func(Test i) : i.value() = 1
Test func(Test i) : i.value() = 0
Result is false!

Test func(Test i) : i.value() = 1
Test func(Test i) : i.value() = 0
Result is true!

Test func(Test i) : i.value() = 0
Test func(Test i) : i.value() = 1
Result is true!

*/

■一些有用的建议
一实际工程开发中避免重载逻辑操作符
一通过重载比较操作符代替逻辑操作符重载
一直接使用成员函数代替逻辑操作符重载
一使用全局函数对逻辑操作符进行重载

逻辑操作符重载后无法完全实现原生的语义
问题的本质分析
1.C++通过函数调用扩展操作符的功能
2.进入函数体前必须完成所有参数的计算
3．函数参数的计算次序是不定的
4．短路法则完全失效

小结

C++从语法上支持逻辑操作符重载
重载后的逻辑操作符不满足短路法则
工程开发中不要重载逻辑操作符
通过重载比较操作符替换逻辑操作符重载
通过专用成员函数替换逻辑操作符重载

第39课 - 逗号操作符的分析

逗号操符（,)构成逗号表达式
一逗号表达式用于将多个子表达式接为一人表达式一逗号表达式的值为最后一个子表达式的值
一逗号表达式中的前N-1人子表达式可以没有返回值
一逗号表达式按照从左向右的顺序计算每个子表达式的值 expl, exp2, exp3, … , expN

实验-逗号表达式

#include <iostream>
#include <string>

using namespace std;

void func(int i)
{
    cout << "func() : i = " << i << endl;
}

int main()
{   
    int a[3][3] = {
        (0, 1, 2),
        (3, 4, 5),
        (6, 7, 8)
    };
  /*int a[3][3] = {
        {0, 1, 2},
        {3, 4, 5},
        {6, 7, 8}
    };*/
    
    int i = 0;
    int j = 0;
    
    while( i < 5 )    
        func(i),
    
    i++;
        
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            cout << a[i][j] << endl;
        }
    }
    
    (i, j) = 6;//j=6
    
    cout << "i = " << i << endl;
    cout << "j = " << j << endl;

    return 0;
}
/*
func() : i = 0
func() : i = 1
func() : i = 2
func() : i = 3
func() : i = 4
2
5
8
0
0
0
0
0
0
i = 3
j = 6

*/

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

实验-重载逗号操作符的问题

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
};
/* case2:
Test& operator , (const Test& a, const Test& b)
{
    return const_cast<Test&>(b);
}
*/
Test func(Test& i)
{
    cout << "func() : i = " << i.value() << endl;
    
    return i;
}

int main()
{   
    Test t0(0);
    Test t1(1);
 //Test tt=(t0,t1);
   // Test tt = (func(t0), func(t1));  case1 调用默认逗号     
    //Test tt = (func(t0), func(t1));  //case2        (operator , (func(t0), func(t1)) ) 等价于 (func(t0), func(t1))
    Test tt = func(t1);//case3
    cout << tt.value() << endl; // 1
    
    return 0;
}
/*
case1:未手动重载逗号
func() : i = 0
func() : i = 1
1
case2:手动重载逗号
func() : i = 1
func() : i = 0
1

func() : i = 1
1

*/

小结

在这里插入图片描述

第40课 - 前置操作符和后置操作符

i++; ++i;
的值作为返回值，i自增自增 1，i 的值作为返回值
//i
下面的代码有没有区别？为什么？

实验-vs2010反汇编

    int i = 0;
000C139E  mov         dword ptr [i],0  

    i++;
000C13A5  mov         eax,dword ptr [i]  
000C13A8  add         eax,1  
000C13AB  mov         dword ptr [i],eax  

    ++i;
000C13AE  mov         eax,dword ptr [i]  
000C13B1  add         eax,1  
000C13B4  mov         dword ptr [i],eax

实验-重载自增操作符

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i)
    {
        mValue = i;
    }
    
    int value()
    {
        return mValue;
    }
    
    Test& operator ++ ()//前置++
    {
        ++mValue;
        
        return *this;
    }
//无后置重载 报错error: no 'operator++(int)' declared for postfix '++' [-fpermissive]
/*
void operator++(int)//编译通过了
{

}*/
Test operator++(int)//优化
{
Test res=*this;//Test res(mValue);//先取值
mValue++;      //再加一
return res;

}
/*
    
    Test operator ++ (int)//后置++
    {
        Test ret(mValue);
        
        mValue++;
        
        return ret;
    }*/
};

int main()
{
    Test t(0);

  

cout<<"t="<<t.value()<<endl;
    
   Test tt= t.operator++(); //Test tt=++t;
cout<<"tt="<<tt.value()<<endl;

cout<<"t="<<t.value()<<endl;
  //前置++ ok
/*
t=0
tt=1
t=1
*/

   // t++;// error: no 'operator++(int)' declared for postfix '++' [-fpermissive]t++;
   // t.operator ++ ();
 Test h(0);

  

cout<<"h="<<h.value()<<endl;
    
   //Test hh=h.operator++(2); //Test hh=h++;
  Test hh=h.operator++(0); //占位参数
cout<<"hh="<<hh.value()<<endl;

cout<<"h="<<h.value()<<endl;
    
    return 0;
}

完善复数类:自增重载

Complex& operator++()
{
a++;
b++;
return *this;

}
Complex operator++(int)
{
Complex ret=*this;//Complex ret(a, b);
a++;
b++;
return ret;

}

小结

在这里插入图片描述

第41课 - 类型转换函数（上）

在这里插入图片描述

实验-隐式类型转换

#include <string>

using namespace std;

int main()
{   
    short s = 'a';
    unsigned int ui = 1000;
    int i = -2000;
    double d = i;
    
    cout << "d = " << d << endl;
    cout << "ui = " << ui << endl;
    cout << "ui + i = " << ui + i << endl;
    
    if( (ui + i) > 0 )
    {
        cout << "Positive" << endl;
    }
    else
    {
        cout << "Negative" << endl;
    }
    
    cout << "sizeof(s + 'b') = " << sizeof(s + 'b') << endl;//编译器并没有隐式转为short
    
    return 0;
}
/*
d = -2000
ui = 1000
ui + i = 4294966296
Positive
sizeof(s + 'b') = 4  */

在这里插入图片描述

实验-类类型与int相互转换

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test()
    {
        mValue = 0;
    }
 /*
explicit Test(int i)
    {
        mValue = i;
    }*/
    
    Test(int i)
    {
        mValue = i;
    }
    
    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);
        
        return ret;
    }/**/
    
    int value()
    {
        return mValue;
    }
};

int main()
{   
    Test t;
    
    //类类型转换为int
   t = static_cast<Test>(5);    // t = Test(5);
    
    
    
    Test r;
    

r = t + 10;//未explicit 构造函数，调用重载，自动隐式转换，r.value()=15,要避免
       // r = t + static_cast<Test>(10);   
//r = t + Test(10);
    cout << r.value() << endl;
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

小结

在这里插入图片描述

第42课 - 类型转换函数（下）

在这里插入图片描述
在这里插入图片描述

实验-类型转换函数operator

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator int ()//类型转换函数
    {
        return mValue;
    }
};

int main()
{   
    Test t(100);
    int i = t;
    
    cout << "t.value() = " << t.value() << endl;   //t.value() = 100

    cout << "i = " << i << endl;                         //i = 100
    
    return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

实验-类型转换成员函数

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value()
    {
    }
    explicit Value(Test& t)//
    {
    }
};

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator Value()//Value ToValue()
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

int main()
{   
    Test t(100);
    Value v = t;//Value v = t.ToValue();
    
    return 0;
}
//operator Value()

在这里插入图片描述

小结

在这里插入图片描述

cyz24
关注
  • 13
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ Primer 5th学习笔记13 操作重载与类型转换
会飞的鱼的博客
04-14 210
操作重载与类型转换 1 基本概念   重载运算符是具有特殊名字的函数：其名字由关键字operator和其后要定义的运算符号共同组成。 可以被重载的运算符如下： 运算符 符号 符号 符号 符号 符号 符号 + - * / % ^ & | ~ ！ , = < > <= >= ++ -- << >> == != &am...
《C++Primer》第十二章-类-学习笔记(2)-作用域&构造函数
工程师小星星
03-03 195
《C++Primer》第十二章-类-学习笔记(2) 文章目录《C++Primer》第十二章-类-学习笔记(2)类作用域使用类的成员作用域与成员定义形参表和函数体处于类作用域中函数返回类型不一定在类作用域中类作用域中的名字查找类成员声明的名字查找类成员定义中的名字查找类成员遵循常规的块作用域名字查找函数作用域之后，在类作用域中查找类作用域之后，在外围作用域中查找在文件中名字的出现处确定名字 日志：...
深蓝学院C++基础与深度解析笔记 第 4 章 表达式
sweetorange_的学习笔记
06-18 686
表达式相关：左右值、操作符等
c++ primer读书笔记-第十四章 重载操作符与转换
梦想还是要有的
07-13 566
C++ 允许我们重定义操作符用于类类型对象时的含义。如果需要，可以像内置转换那样使用类类型转换，将一个类型的对象隐式转换到另一类型。 例如标准库为容器类定义了几个重载操作符。这些容器类定义了下标操作符以访问数据元素，定义了 * 和 -> 对容器迭代器解引用。重载操作符的定义1.重载操作符是具有特殊名称的函数：保留字 operator后接需定义的操作符号。像任意其他函数一样，重载操作符具有返回类型和
详解C++-(=)赋值操作符、智能指针编写
12-25
默认的赋值操作符和默认的拷贝构造函数有相同的存在意义 (=)赋值操作符注意事项 首先要判断两个操作数是否相等 返回值一定是 return *this; 返回类型是Type&型,避免连续使用=后,出现bug 比如: class Test{ int *p...
C++中Operator类型强制转换成员函数解析
01-20
类型转换操作符（type conversion operator）是一种特殊的类成员函数，它定义将类类型值转变为其他类型值的转换。转换操作符在类定义体内声明，在保留字 operator 之后跟着转换的目标类型。转换函数又称类型强制转换...
C++笔记之指向函数类型的指针
01-21
像其他指针一样，函数指针也指向某个特定的类型，函数类型有返回类型以及形参表确定，而与函数名无关。     bool (*pf) (const string ，const string &);   　这个语句将pf申明为指向函数的...
C++学习笔记--函数指针
07-23
C++学习笔记--函数指针 函数指针 程序运行期间。每个函数都会占用一段连续的内存空间。而函数名就是该函数所占内存区域的起始地址（也称“入口地址”）。我们可以将函数入口地址赋给一个指针变量，使该指针变量...
函数模板与类模板
程序员_小兵
07-12 1554
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
I_feige的博客
07-12 321
1.
C++ 多态
wxk2227814847的博客
07-10 790
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
Reversing Numbers C++
FGGFFoj的博客
07-11 377
在默认情况下，C++的输入输出流（比如 cin, cout）与C标准库的输入输出流是同步的，这意味着在使用C++的输入输出流时，可能会因为需要与C标准库的同步而导致性能略有损失。在 C++ 中，默认情况下，cin 和 cout 是绑定在一起的，意味着在输入时，输出可能需要等待输入完成才会进行，这样可能会造成一些性能上的损失，特别是在需要频繁输入输出的场景下。需要注意的是，在取消同步后，应确保不要混合使用C++的输入输出和C标准库的输入输出，因为这可能会导致未定义的行为。
c++ 生成随机字符串
最新发布
m0_56306892的博客
07-15 96
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C++：哈希表
m0_61088872的博客
07-12 702
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1017
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
m0_70748845的博客
07-12 353
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 418
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 300
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值