【与C++的邂逅】--- 类与对象(下)

2024-08-23 22:44
文章标签 c++ 对象 邂逅

本文主要是介绍【与C++的邂逅】--- 类与对象(下)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:        9ilk

(๑•́ ₃ •̀๑) 文章专栏：     与C++的邂逅 

本节我们继续学习类与对象下，下面给出本节内容大纲。

🏠 再谈构造

📌 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值 。 
class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，是一种"伪初始化"，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

📌 初始化列表

class Stack
{
public:Stack(size_t capacity){//..}
private:int _top;int _array;int _size;
};class MyQueue
{
private:Stack _pushst;Stack _popst;int _size;
};int main()
{MyQueue q;return 0;
}

对于MyQueue这样的类，我们建议构造时使用编译器默认生成的构造，此时对它的自定义类型成员调用默认构造，但是Stack类中由于显示实现了有参构造，此时没有默认构造，该如何对MyQueue类对象初始化呢？

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
此时可以利用初始化列表进行初始化,在初始化列表中显示对自定义类型调有参构造： 
MyQueue(int n) //显示写构造:_pushst(n),_popst(n),_size(0)
{}

对于初始化列表我们需要了解以下几点：

  • 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)，初始化列表本质上可以理解为每个对象中成员定义的地方(毕竟类只能在定义的时候构造). 
class MyQueue
{
public:MyQueue(int n) //显示写构造 定义的地方:_pushst(n),_popst(n),_size(0){}private:  //声明Stack _pushst;Stack _popst;int _size;
};
  • 类中所有成员既可以在初始化列表初始化，也可以在函数体；但以下类型必须在初始化列表初始化：
1. const成员变量。(const修饰变量只有一次初始化机会，需要在定义时给他一个值)
2. 引用成员变量。(引用定义时需要给他一个值，而且不能改变指向)
3.无默认构造的自定义类型成员。(这类成员必须显示传参调构造)
  • 尽量使用初始化列表初始化。因为不管你是否显示写，成员变量都会走初始化列表，自定义类型调用它的默认构造。

  • 缺省值是给初始化列表准备的。

1. 内置类型有缺省值初始化列表用缺省值，没有的话不确定，看编译器，有的编译器会处理，有的不会处理。

2. 自定义类型成员初始化列表会调用默认构造(没有默认构造会编译报错)，自定义类型成员在声明时也可以给缺省，如果初始化列表显示调用该成员构造就不用这个缺省。

  • 初始化列表对成员变量的初始化内容可以是变量，常量，表达式，函数调用等。
int fun()
{return 1;
}MyQueue(int n =1):_size(n+1), //表达式 也可以是_size(fun())_capacity(1),//常量_ptr((int*)malloc(8)) 
{}
  • 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
    次序无关 。 
class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout<<_a1<<" "<<_a2<<endl;}
private:int _a2;int _a1;
};int main()
{A aa(1);aa.Print();
}A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

本题正确答案为1。

由于声明顺序即初始化列表中初始化顺序，因此会先初始化a2，此时a1还未初始化，a2就被初始化为随机值，a1正常初始化为1.

  • 实践中我们尽可能使用初始化列表初始化，不方便再用函数体初始化。
MyQueue():_size(1),_ptr((int*)malloc(40))
{memset(_ptr,1,40); //此时适合用函数体
}

对于自定义类型使用初始化列表初始化列表可以提高效率。

class B
{
public:B(int ab= 9){cout << "B()" << endl;}
private:int _b = 2; //用缺省值初始化
};class A
{
public:A():_b(2) //初始化列表初始化 {}A(int a) //不用初始化列表初始化{B hh;_b = hh;}private:int _a2;int _a1;B _b;
};

说明：

  1. 用初始化列表对自定义成员进行初始化，此时只会调用一次构造，无论默认构造还是其他构造。
  2. 如果想在函数体内对自定义成员初始化，无论是否显示写，都会先对自定义成员调用默认构造，再在类内调用一次构造和拷贝构造，无疑是降低效率的。

对于内置类型成员，它走不走初始化列表初始化，其初始化和赋值成本相同，但是为了一致性最好也通过初始化列表初始化。

📌explic关键字

📒 隐式类型转换

  • 单参数隐式类型转换
class A
{
public:A(int a  = 2):_a(a){}
private: int _a;
};int main()
{A aa1(1);//拷贝构造A aa2 = aa1;//单参数隐式类型转换  内置类型->自定义类型A aa3 = 3;return 0;
}

对于aa3这个对象，直接将int转化给A类型是转不过去的；它会先用3构造出一个临时对象，再对这个临时对象进行拷贝创建aa3.我们C语言阶段对变量的赋值，比如int d = n + 3，也会产生临时变量储存运算结果。

 由于产生的临时对象具有“常性”，如果要用引用介绍的话需要用const引用。

const A& a1 = 3;

好处：方便和提高代码可读性。

class Stack
{
public:void push(const A& aa){//...}
//...
};int main()
{Stack st;//以前是传对象A a1(1);st.push(a1);//现在用隐式类型转换更加清晰且减少代码量st.push(3);
}

  • 多参数隐式类型转换
class A
{
public:A(int a1,int a2):_a(0),_a1(a1),_a2(a2){}private:int _a;int _a1;int _a2;
};int main()
{A aa1(1,2);A aa2 = {1,2};const A& aa3 = {1,2};return 0;
}

说明：

1. 对于aa1调用的其实是单参构造，因为逗号表达式返回的是括号最右边的结果。

2.对于aa2其实是进行了多参数的隐式类型转换，编译器用{1,2}调用了多参构造生成临时对象，再对这个临时对象进行拷贝创建新对象。

3. 对于aa3,由于临时对象具有常性，因此需要用const引用接收。

  • 隐式类型转换与缺省值

我们前面知道缺省值是给初始化列表准备的，我们也可以在自定义类型成员声明时给缺省值，可以对他们进行隐式类型转换或者拷贝。

class B
{private:A _a1 = 1; //单参隐式类型A _a2 = {1,2};//多参隐式类型转换A _a3 = _a2;//拷贝
};

📒 explicit关键字作用

我们若是想禁止构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

class Date
{
public:// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译explicit Date(int year):_year(year){}// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
有类型转换作用// explicit修饰构造函数，禁止类型转换explicit Date(int year, int month = 1, int day = 1):_year(year),_month(month),_day(day){}Date& operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}private:int _year;int _month;int _day;
};void Test()
{Date d1(2022);// 用一个整形变量给日期类型对象赋值// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值d1 = 2023;// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转
换的作用
}

🏠 static成员

📌static成员变量

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量。
  • 静态成员不存在对象中，存在静态区
class A
{
public:A(){++_scount;}A(const A& t){ ++_scount;}~A() {--_scount;}
private:int _a1;int _a2;static int _scount; //静态成员
};int main()
{A aa1;cout << sizeof(aa1) << endl;return 0;
}

输出：8 

结论：对象中只存非静态成员变量，不存静态成员和成员函数。

  • 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。 
class A
{
public:A(){++_scount;}A(const A& t){ ++_scount;}~A() {--_scount;}
private:int _a1;int _a2;static int _scount; //静态成员
};int A::_scount = 0; //定义

静态成员变量不能给缺省值，因为缺省值是给走初始化列表的成员准备的，静态成员变量不存在对象中，因此不走初始化列表，也就不能给缺省值。

  • 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
  • 类静态成员即可用 类名::静态成员 或者 对象.静态成员来访问。 
//前提是公有
//对象.静态成员
aa1._scount;
//类名::静态成员
cout << A::_scount << endl;
  • 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
应用： 
//1.可以利用对象共享静态成员变量计数多少个对象被创建
A()
{++_scount;
}//2.计数有多少对象存活
~A()
{--_scount;
}//3.方便我们查看是否拷贝
A(const A& t)
{++_scount;
}

我们访问静态成员变量前提是它的访问权限是公有，如果它是私有，我们有什么方法对其进行访问呢？此时我们可以利用静态成员函数进行访问。

📌static成员函数

用static修饰的成员函数，称之为静态成员函数。
  • 静态成员函数没有隐藏的this指针，不能访问任何非静态成员，它只能访问静态成员变量 。 
class A
{
public:static int GetN(){return _n;}
private:static int _n;
};int A::_n = 0;
int main()
{A a;cout << a.GetN() << endl; //1.通过对象调用成员函数进行访问cout << A().GetN() << endl; //2.通过匿名对象调用成员函数进行访问cout << A::GetN() << endl; //3.通过类名调用静态成员函数进行访问return 0;
}

注：静态成员函数能直接指定类域调用，是因为它没有this指针，不需要对象传指针。

【问题】

1. 静态成员函数可以调用非静态成员函数吗？

2. 非静态成员函数可以调用类的静态成员函数吗？

1. 不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。

2. 可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

  • 构造是特殊的成员函数，静态成员函数也不能调用构造，但能间接调用。
class A
{
public:static A func(){return A();}};

注：这里并不是在静态成员函数里调用非静态成员函数，而是通过定义一个对象间接调用构造，定义对象并不需要this指针。

🏠 友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

📌友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。 
class Date
{friend ostream& operator<<(ostream& _cout, const Date& d); //友元声明friend istream& operator>>(istream& _cin, Date& d);
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{_cin >> d._year;_cin >> d._month;_cin >> d._day;return _cin;
}
  • 友元函数可访问类的私有和保护成员，但不是类的成员函数 。
  • 友元函数不能用const修饰。

这是因为友元函数并不是类的成员函数，类的成员函数含有this指针，this指针才需要被const修饰。

  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
  • 一个函数可以是多个类的友元函数。
  • 友元函数的调用与普通函数的调用原理相同。

📌友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
  • 友元关系是单向的，不具有交换性。
比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
  • 友元关系不能传递。
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
  • 友元关系不能继承。

🏠 内部类

📌概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

📌特性

  • 内部类可以定义在外部类的public、protected、private都是可以的。
  • 内部类和外部类是两个平行的类， 内部类并不是它的成员，内部类是个独立的类， 它仅仅是受到外部类的类域限制。 
class A
{
private:static int k;int h;
public:void fun(){}
//内部类class B{public:void foo(const A & a){ //...}private:int _b; };};int main()
{cout << sizeof(A) << endl;A::B b1;
}

由于内部类是独立的所以sizeof(外部类)和内部类没有任何关系，由于内部类声明在外部类，因此创建内部类对象时，需要指明外部类的类域。

  • 内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
  • 内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

🏠 匿名对象

📌 特点

  • 匿名对象不需要对象名，且生命周期很短，创建完即销毁。
class Test
{
public:~Test()
{cout << "~Test()" << endl;
}Test()
{cout << "Test()" << endl;
}};int main()
{Test();cout << "111111111" <<endl;
}

📌 好处

void f1(const A& aa)
{}int main()
{
//传值传参A aa1;f1(aa1);
//匿名对象
f1(A());
}
在这种场景下使用匿名对象就方便不少。
注：匿名对象也具有类似临时对象的"常性"，也需要用const引用接收。

🏠 拷贝里的编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
  • 一个表达式中，连续构造+拷贝构造->优化为一个构造。(多个式子则不会优化) 
class Test
{
public:Test(int t = 10):_t(t){cout << "Test()" << endl;}Test(const Test& t){cout << "Test(const Test& t)" << endl;} ~Test(){cout << "~Test()" << endl;}private:int _t;
};void f1(Test t)
{}int main()
{Test t1;f1(t1);cout << endl;f1(Test(2));cout << endl;f1(2);cout << "111111111" << endl;
}

输出结果：

//不是一个连续表达式 不优化

Test()
Test(const Test& t)
~Test()

 //优化

Test()
~Test()

//优化

Test()
~Test()
111111111
~Test() //t1析构

  • 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 
A f2()
{A aa;return aa;
}int main()
{A ret1 = f2();const A& ret2 f2();
}

注：对于ret1是一个表达式中进行连续的拷贝构造+拷贝构造会进行优化，而ret1由于是传引用传参所以不会优化。

  • 一个表达式中，连续拷贝构造+赋值重载->无法优化 
A f2()
{A aa;return aa;
}int main()
{A ret;ret2  = f2();cout << endl;return 0;
}

此时是连续的拷贝构造+拷贝赋值重载，两者不是一个性质，所以无法进行优化。

🏠 再次理解类和对象

类是对某一类实体 ( 对象 ) 来进行描述的，描述该对象具有那 些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化 具体的对象 。

本节我们更深刻关于构造函数对成员的初始化机理，以及学习了特殊的stactic成员，内部类，匿名对象和友元技术，通过这些我们更能理解类和对象之间的关系。

这篇关于【与C++的邂逅】--- 类与对象(下)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1100705。

相关文章

Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
C/C++错误信息处理的常见方法及函数

C/C++错误信息处理的常见方法及函数

《C/C++错误信息处理的常见方法及函数》C/C++是两种广泛使用的编程语言,特别是在系统编程、嵌入式开发以及高性能计算领域,：本文主要介绍C/C++错误信息处理的常见方法及函数,文中通过代码介绍... 目录前言1. errno 和 perror()示例：2. strerror()示例：3. perror(
阅读更多...
C++变换迭代器使用方法小结

C++变换迭代器使用方法小结

《C++变换迭代器使用方法小结》本文主要介绍了C++变换迭代器使用方法小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1、源码2、代码解析代码解析：transform_iterator1. transform_iterat
阅读更多...
详解C++中类的大小决定因数

详解C++中类的大小决定因数

《详解C++中类的大小决定因数》类的大小受多个因素影响,主要包括成员变量、对齐方式、继承关系、虚函数表等,下面就来介绍一下,具有一定的参考价值,感兴趣的可以了解一下... 目录1. 非静态数据成员示例：2. 数据对齐（Padding）示例：3. 虚函数（vtable 指针）示例：4. 继承普通继承虚继承5.
阅读更多...
C++中std::distance使用方法示例

C++中std::distance使用方法示例

《C++中std::distance使用方法示例》std::distance是C++标准库中的一个函数,用于计算两个迭代器之间的距离,本文主要介绍了C++中std::distance使用方法示例,具... 目录语法使用方式解释示例输出：其他说明：总结std::distance&n编程bsp;是 C++ 标准
阅读更多...
在java中如何将inputStream对象转换为File对象(不生成本地文件)

在java中如何将inputStream对象转换为File对象(不生成本地文件)

《在java中如何将inputStream对象转换为File对象(不生成本地文件)》：本文主要介绍在java中如何将inputStream对象转换为File对象(不生成本地文件),具有很好的参考价... 目录需求说明问题解决总结需求说明在后端中通过POI生成Excel文件流，将输出流（outputStre
阅读更多...
C++ 中的 if-constexpr语法和作用

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if（staticif）,：本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa
阅读更多...
C++中::SHCreateDirectoryEx函数使用方法

C++中::SHCreateDirectoryEx函数使用方法

《C++中::SHCreateDirectoryEx函数使用方法》::SHCreateDirectoryEx用于创建多级目录,类似于mkdir-p命令,本文主要介绍了C++中::SHCreateDir... 目录1. 函数原型与依赖项2. 基本使用示例示例 1：创建单层目录示例 2：创建多级目录3. 关键注
阅读更多...
C++从序列容器中删除元素的四种方法

C++从序列容器中删除元素的四种方法

《C++从序列容器中删除元素的四种方法》删除元素的方法在序列容器和关联容器之间是非常不同的,在序列容器中,vector和string是最常用的,但这里也会介绍deque和list以供全面了解,尽管在一... 目录一、简介二、移除给定位置的元素三、移除与某个值相等的元素3.1、序列容器vector、deque
阅读更多...
C++常见容器获取头元素的方法大全

C++常见容器获取头元素的方法大全

《C++常见容器获取头元素的方法大全》在C++编程中,容器是存储和管理数据集合的重要工具,不同的容器提供了不同的接口来访问和操作其中的元素,获取容器的头元素（即第一个元素）是常见的操作之一,本文将详细... 目录一、std::vector二、std::list三、std::deque四、std::forwa
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2