C++/类和对象/2

pzn）

于 2024-09-11 22:20:54 发布

阅读量606

点赞数 45

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/pzn2506/article/details/142105806

版权

C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

欢迎

1.初始化列表

构造函数初始化还有⼀种⽅式，就是初始化列表，初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。
每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。
引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。
C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。
初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。建议声明顺序和初始化列表顺序保持⼀致。

#include<iostream>
using namespace std;

void Test()
{
	//动态申请一个int类型的空间
	int* ptr1 = new int;
	//动态申请一个int类型的空间并初始化为10
	int* ptr2 = new int(10);
	//动态申请10个int类型的空间
	int* ptr3 = new int[10];

	delete ptr1;
	delete ptr2;
	delete[] ptr3;
}
class A
{
public:
	A(int a=0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
	//还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;

	//内置类型几乎是一样
	int* p3 = (int*)malloc(sizeof(A) * 10);
	int* p4 = new int;
	free(p3);
	delete p4;

}

2.类型转换

C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数、

构造函数前⾯加explicit就不再⽀持隐式类型转换

#include<iostream>
using namespace std;
class A
{
public:
// 构造函数explicit就不再⽀持隐式类型转换
// explicit A(int a1)
A(int a1)
:_a1(a1)
{}
//explicit A(int a1, int a2)
A(int a1, int a2)
:_a1(a1)
,_a2(a2)
{}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a1 = 1;
int _a2 = 2;
};
int main()
{
// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3
// 编译器遇到连续构造+拷⻉构造->优化为直接构造
A aa1 = 1;
aa1.Print();
const A& aa2 = 1;
// C++11之后才⽀持多参数转化
A aa3 = { 2,2 };
return 0;
}

3.static成员

⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。
静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。
⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数
静态成员也是类的成员，受public、protected、private 访问限定符的限制。
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不⾛构造函数初始化列表

#include<iostream>
using namespace std;

class A
{
public:
    // 默认构造函数
    A()
    {
        ++_scount;  // 每创建一个对象，_scount 递增
    }

    // 拷贝构造函数
    A(const A& t)
    {
        ++_scount;  // 每复制一个对象，_scount 递增
    }

    // 析构函数
    ~A()
    {
        --_scount;  // 每销毁一个对象，_scount 递减
    }

    // 静态成员函数，用于获取当前类的对象数量
    static int GetACount()
    {
        return _scount;  // 返回静态成员变量 _scount 的值
    }

private:
    // 静态成员变量，记录当前类对象的数量
    static int _scount;
};

// 静态成员变量初始化
int A::_scount = 0;

int main()
{
    cout << A::GetACount() << endl;  // 输出当前对象数量，初始为 0
    
    A a1, a2;  // 创建两个对象 a1 和 a2，对象数量 _scount 增加到 2
    A a3(a1);  // 通过拷贝构造函数创建对象 a3，对象数量 _scount 增加到 3
    
    cout << A::GetACount() << endl;  // 输出当前对象数量，应该为 3
    cout << a1.GetACount() << endl;  // 也可以通过对象调用静态函数，输出对象数量，应该为 3

    // 编译报错：error C2248: “A::_scount”: 无法访问 private 成员（在“A”类中声明）
    // cout << A::_scount << endl;  // 尝试直接访问私有静态成员 _scount，会导致编译错误

    return 0;
}

3.1static的使用

求1+2+3+...+n_牛客题霸_牛客网 (nowcoder.com)

此题目要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。便可使用静态成员来完成

class Sum
{
public:
    Sum() // 构造函数
    {
        _ret += _i; // 将静态成员 _i 的值加到静态成员 _ret 上
        ++_i; // 自增静态成员 _i
    }
    static int GetRet() // 静态成员函数，用于获取 _ret 的值
    {
        return _ret;
    }
private:
    static int _i; // 静态成员变量，记录当前的值
    static int _ret; // 静态成员变量，记录累积的结果
};

// 静态成员变量初始化
int Sum::_i = 1; // 初始值为 1
int Sum::_ret = 0; // 初始值为 0

class Solution {
public:
    int Sum_Solution(int n) {
        // 创建长度为 n 的 Sum 对象数组
        Sum arr[n];
        // 返回静态成员 _ret 的值
        return Sum::GetRet();
    }
};

Sum 类的构造函数在每次实例化时都会修改 _ret 和 _i。

当 Solution 函数创建 n 个 Sum 对象时，每个对象都会触发构造函数，使得 _ret 累加 _i 的值。

4.友元

友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。
外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
⼀个函数可以是多个类的友元函数。
友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是B的友元。
有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多⽤。

#include<iostream>
using namespace std;

// 前置声明，声明类 B，确保编译器知道 B 的存在
class B;

// 类 A 的定义
class A
{
    // 友元函数声明，表示函数 func 可以访问 A 的私有成员
    friend void func(const A& aa, const B& bb);

private:
    int _a1 = 1; // A 的私有成员变量 _a1，初始值为 1
    int _a2 = 2; // A 的私有成员变量 _a2，初始值为 2
};

// 类 B 的定义
class B
{
    // 友元函数声明，表示函数 func 可以访问 B 的私有成员
    friend void func(const A& aa, const B& bb);

private:
    int _b1 = 3; // B 的私有成员变量 _b1，初始值为 3
    int _b2 = 4; // B 的私有成员变量 _b2，初始值为 4
};

// 友元函数的定义，访问 A 和 B 的私有成员
void func(const A& aa, const B& bb)
{
    cout << aa._a1 << endl; // 输出 A 对象的私有成员 _a1 的值
    cout << bb._b1 << endl; // 输出 B 对象的私有成员 _b1 的值
}

int main()
{
    A aa; // 创建 A 类的对象 aa
    B bb; // 创建 B 类的对象 bb

    func(aa, bb); // 调用友元函数 func，传入 A 和 B 对象
    
    return 0; 
}

friend void func(const A& aa, const B& bb); 表示 func 函数是 A 和 B 的友元函数，这允许它访问这两个类的私有成员。

5.内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。
内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地⽅都⽤不了。

#include <iostream>
using namespace std;

class A
{
private:
    static int _k; // 静态成员变量，属于类而不是实例
    int _h = 1;    // 普通成员变量，属于每个实例

public:
    // 内部类 B 默认是类 A 的友元类
    class B
    {
    public:
        // 成员函数 foo，接受一个常量引用的 A 类型对象
        void foo(const A& a)
        {
            cout << _k << endl; // 输出静态成员 _k 的值
            cout << a._h << endl; // 输出实例 a 的成员 _h 的值
        }
    };
};

// 静态成员变量的定义和初始化
int A::_k = 1;

int main()
{
    cout << sizeof(A) << endl; // 输出类 A 的大小（通常为 4 或 8 字节，取决于平台和编译器）

    A::B b;  // 创建类 A 的内部类 B 的对象
    A aa;    // 创建类 A 的对象

    b.foo(aa); // 调用 B 的成员函数 foo，传入 A 的对象 aa

    return 0;
}

6.匿名对象

⽤类型(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的类型对象名(实参) 定义出来的叫有名对象
匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。
匿名对象：没有名字的对象，仅在创建的那一行有效。它们的生命周期仅限于当前语句，创建后立刻被销毁，因此它们的析构函数会立即被调用。

#include <iostream>
using namespace std;

class A
{
public:
    // 构造函数，具有一个默认参数值 0
    A(int a = 0)
        : _a(a)  // 初始化成员变量 _a
    {
        cout << "A(int a)" << endl;  // 打印构造函数调用的提示信息
    }

    // 析构函数
    ~A()
    {
        cout << "~A()" << endl;  // 打印析构函数调用的提示信息
    }

private:
    int _a;  // 成员变量，用于存储传递给构造函数的值
};

class Solution {
public:
    // 函数 Sum_Solution，计算从 1 到 n 的和（实际实现部分省略）
    int Sum_Solution(int n) {
        // ... 这里应该有实现代码
        return n;  // 返回 n，实际实现中应该返回 1 到 n 的和
    }
};

int main()
{
    A aa1;    // 创建一个对象 aa1，调用 A(int a) 构造函数，输出 "A(int a)"
    
    // 下面的定义是一个函数声明，而不是对象定义
    // A aa1();  // 这是一个函数声明，不是对象定义

    // 下面这行创建了一个匿名对象，调用 A(int a) 构造函数，输出 "A(int a)"
    A();      // 匿名对象的生命周期只在这一行中
    
    // 下面这行创建了另一个匿名对象，调用 A(int a) 构造函数，输出 "A(int a)"
    A(1);     // 匿名对象的生命周期只在这一行中

    // 创建一个对象 aa2，调用 A(int a) 构造函数，输出 "A(int a)"
    A aa2(2); // 该对象在作用域内有效，并在程序结束时析构，输出 "~A()"

    // 创建一个 Solution 对象并调用 Sum_Solution 函数
    Solution().Sum_Solution(10);

    return 0;
}