C++ 模板基础知识——类模板中的友元

已于 2024-08-31 08:56:29 修改
阅读量1.4k 收藏 26
点赞数 42
分类专栏： # C++模板与泛型编程 文章标签： c++ 开发语言
于 2024-08-31 00:01:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141724289
版权

目录

C++ 模板基础知识——类模板中的友元

1. 友元类基础概念

在C++中，友元是一种特殊的关系，允许一个类或函数访问另一个类的私有和保护成员。这种机制虽然打破了封装性，但在某些情况下是必要的。

1.1 传统友元类

在传统的友元关系中，如果类B是类A的友元，那么类B可以访问类A的所有成员，包括私有和保护成员。

class A {
private:
    int data;
    friend class B; // 声明 B 为 A 的友元类
public:
    A(int value) : data(value) {}
};

class B {
public:
    void accessA(A& obj) {
        // B 可以访问 A 的私有成员
        std::cout << "A's data: " << obj.data;
    }
};

2. 类模板中的友元关系

当友元概念扩展到类模板时，情况变得更加复杂和灵活。有三种主要方式来定义类模板之间的友元关系：

2.1 让类模板的某个实例成为友元类

这种方式允许一个具体化的类模板实例成为另一个类的友元。这是通过在类定义中指定模板参数来实现的。

template <typename T>
class MyClass;

template <typename T>
class FriendClass {
    public:
    void showData(const MyClass<T>& obj);
};

template <typename T>
class MyClass {
private:
    T data;
    friend void FriendClass<T>::showData(const MyClass<T>& obj);
public:
    MyClass(T d) : data(d) {}
};

template <typename T>
void FriendClass<T>::showData(const MyClass<T>& obj) {
    std::cout << "MyClass data: " << obj.data << std::endl;
}

这个例子的关键点和注意事项：

  1. 在类中通过指定具体的模板实例化类型来声明友元类，例如 friend void FriendClass<T>::showData(const MyClass<T>& obj);。这样声明将使得特定类型的 FriendClass 实例能够访问 MyClass 的私有数据。
  2. 这种方法的封装性较好，因为它只允许特定的模板实例访问私有成员，而不是所有可能的实例。
  3. 确保模板类 FriendClass 在使用之前已被定义或声明，以避免编译错误。

2.2 让类模板成为友元类模板

在这种情况下，一个类模板的所有实例都可以成为另一个类模板的友元。这通常通过在友元声明中使用模板参数来实现。

template <typename T>
class MyClass;

template <typename T>
class AllInstancesFriend {
    public:
    void accessData(const MyClass<T>& obj);
};

template <typename T>
class MyClass {
private:
    T data;
    template <typename U>
    friend void AllInstancesFriend<U>::accessData(const MyClass<U>& obj);
public:
    MyClass(T d) : data(d) {}
};

template <typename T>
void AllInstancesFriend<T>::accessData(const MyClass<T>& obj) {
    std::cout << "Accessing MyClass data: " << obj.data << std::endl;
}

这个例子的关键点和注意事项：

  1. 使用模板参数在友元声明中，如 template <typename U> friend void AllInstancesFriend<U>::accessData(const MyClass<U>& obj); 允许任何 AllInstancesFriend<U> 的实例访问 MyClass<U> 的私有成员。
  2. 这种方法的灵活性很高，适合那些需要广泛访问不同类型实例的场景。
  3. 可能会降低封装性，因为所有实例都可以访问私有成员。使用时需要谨慎考虑是否真的需要这种广泛的访问权限。

2.3 让类型模板参数成为友元类

此方法允许将模板参数本身用作友元。这样，任何以这种类型为模板参数的类都能访问原始类的私有成员。

template <typename T>
class MyClass {
private:
    T data;
    friend T;
public:
    MyClass(T d) : data(d) {}
};

class SpecificFriend {
public:
    void displayData(const MyClass<SpecificFriend>& obj) {
        std::cout << "Data: " << obj.data << std::endl;
    }
};

这个例子的关键点和注意事项：

  1. 直接将类型模板参数作为友元，如 friend T;，这意味着任何以这种类型为模板参数的类实例都可以访问原始类的私有成员。
  2. 这种方法提供了极高的灵活性，允许具体类型与数据类紧密结合。
  3. 这种方式可能会导致封装性的大幅度降低，特别是当被广泛使用时。需要仔细控制哪些类型可以作为友元，以避免潜在的安全风险和设计问题。

3. 友元函数

3.1 友元函数的基本概念

友元函数是一种特殊的函数，它不是类的成员，但被授予了访问类的私有和保护成员的权限。在 C++ 中，类的成员通常被分为公有（public）、保护（protected）和私有（private）三种访问级别。私有成员只能在类的内部访问，这有助于保护数据和实现细节。然而，有时候需要允许类外的特定函数访问私有成员，这就是友元函数的用途。

关键点和注意事项：

  1. 友元函数是一种特殊的非成员函数，它可以访问类的私有和保护成员。
  2. 友元函数在类内部使用 friend 关键字声明，但实际的函数定义在类外部。
  3. 友元关系是单向的，不具有传递性。
  4. 友元函数可以在类的任何访问修饰符部分（public、protected 或 private）声明，不影响其访问权限。
  5. 友元函数可以直接访问类的私有成员，无需通过公有接口。
  6. 友元函数可以访问类的所有实例的私有成员，而不仅限于特定实例。

3.2 普通友元函数示例

class Box {
private:
    int width;
public:
    Box(int w) : width(w) {}
    friend void printWidth(Box box);
};

void printWidth(Box box) {
    // 友元函数可以直接访问 Box 的私有成员
    cout << "Width of box: " << box.width << endl;
}

int main() {
    Box box(5);
    printWidth(box);  // 输出：Width of box: 5
    return 0;
}

在这个例子中，printWidth 函数被声明为 Box 类的友元，因此它可以访问 Box 的私有成员 width。

3.3 友元函数模板

当友元函数和函数模板结合时，就形成了友元函数模板。这允许一个模板函数成为类的友元，可以访问类的私有成员。

3.3.1 让函数模板的所有实例成为友元
#include <iostream>

class MyClass {
private:
    int data;
public:
    MyClass(int d) : data(d) {}

    template<typename T>
    friend void printData(const MyClass& obj, T value);
};

template<typename T>
void printData(const MyClass& obj, T value) {
    std::cout << "Data: " << obj.data << ", Value: " << value << std::endl;
}

int main() {
    MyClass obj(10);
    printData(obj, 20);   // 输出：Data: 10, Value: 20
    printData(obj, 3.14); // 输出：Data: 10, Value: 3.14
    return 0;
}

在这个例子中，printData 函数模板的所有实例都是 MyClass 的友元。

这个例子的关键点和注意事项：

  1. 在类内部使用 template<typename T> friend void functionName(...) 语法声明友元函数模板。这样声明会使该函数模板的所有实例都成为类的友元。
  2. 需要在类定义之前声明函数模板，或者在类内部直接定义友元函数模板。这是因为编译器需要在遇到友元声明时知道函数模板的存在。
  3. 这种方式允许函数模板的所有实例访问类的私有成员，可能会降低封装性。因此，在使用时需要权衡利弊，确保不会过度暴露类的内部实现。
3.3.2 让函数模板的特定实例成为友元
#include <iostream>
#include <type_traits>

// 前向声明函数模板
template<typename T>
void printData(const class MyClass& obj, T value);

class MyClass {
private:
    int data;

public:
    MyClass(int d) : data(d) {}

    // 只有 int 类型的实例是友元
    friend void printData<int>(const MyClass& obj, int value);

    // 可选：声明整个函数模板为友元
    // template<typename T>
    // friend void printData(const MyClass& obj, T value);
};

// 函数模板定义
template<typename T>
void printData(const MyClass& obj, T value) {
    if constexpr (std::is_same_v<T, int>) {
        // 只有当 T 是 int 时，才能访问私有成员
        std::cout << "Class data: " << obj.data << ", Int value: " << value << std::endl;
    } else {
        std::cout << "Cannot access private data. Value: " << value << std::endl;
    }
}

int main() {
    MyClass obj(42);
    printData(obj, 10);    // 可以访问私有数据
    printData(obj, 3.14);  // 不能访问私有数据
    printData(obj, "Hello");  // 不能访问私有数据

    return 0;
}

这个例子的关键点和注意事项：

  1. friend void printData<int>(const MyClass& obj, int value); 这行声明了 printData<int> 的特化版本为友元。这意味着只有当 T 为 int 时，printData 才是 MyClass 的友元。
  2. template<typename T> friend void printData(const MyClass& obj, T value); 这行声明整个函数模板为友元。根据具体需求，这行可以保留或删除。
    • 如果保留，所有的 printData 实例都是友元，但函数内部仍然只在 T 为 int 时访问私有成员。
    • 如果删除，只有 int 特化版本是友元。
  3. 在函数模板定义中，使用 if constexpr 在编译时检查 T 是否为 int。这确保了只有在 T 为 int 时才访问私有成员 data。
  4. 即使声明了整个模板为友元，函数内部的逻辑仍然可以控制对私有成员的访问。

3.4 在类模板中使用友元函数

当涉及类模板时，友元函数的声明变得更加复杂：

#include <iostream>

// 前向声明
template<typename T>
class MyClass;

// 友元函数模板的声明
template<typename T>
void printData(const MyClass<T>& obj);

template<typename T>
class MyClass {
private:
    T data;

public:
    MyClass(T d) : data(d) {}

    // 声明友元函数模板
    friend void printData<T>(const MyClass<T>& obj);

    // 另一种方式：声明所有实例为友元
    // template<typename U>
    // friend void printData(const MyClass<U>& obj);
};

// 友元函数模板的定义
template<typename T>
void printData(const MyClass<T>& obj) {
    std::cout << "Data: " << obj.data << std::endl;
}

int main() {
    MyClass<int> intObj(42);
    MyClass<double> doubleObj(3.14);

    printData(intObj);     // 输出: Data: 42
    printData(doubleObj);  // 输出: Data: 3.14

    return 0;
}

在这个例子中，printData 函数模板被声明为 MyClass 模板的友元，允许它访问任何 MyClass 实例的私有成员。

这个例子的关键点和注意事项：

  1. 在类模板中声明友元函数需要额外的模板参数，以处理类模板的参数。这是因为类模板的每个实例都是一个不同的类型，需要相应的友元函数。
  2. 友元函数模板可以访问任何类模板实例的私有成员。这提供了极大的灵活性，允许创建能够处理不同类型的通用友元函数。
  3. 需要在类模板外部定义友元函数模板。定义时需要注意模板参数的使用，以确保与类模板的参数正确对应。
  4. 编译器会根据类模板的实际类型自动推导友元函数的模板参数。这简化了友元函数的使用，不需要显式指定模板参数。

总结

  1. 友元关系不是传递的：如果类A是类B的友元，类B是类C的友元，这不会使类A成为类C的友元。这是因为友元关系仅限于明确声明它们的类和函数之间。

  2. 友元声明的位置不影响访问权限：友元声明可以位于类定义的任何部分，无论是公开、保护还是私有区域，其效果都是相同的。这是因为友元的作用是授予访问权限，而不是定义访问级别。

  3. 友元函数或友元类不是成员：友元函数或类不是类的一部分，它们不受类的封装边界的限制。它们只是有权访问类的非公开成员。

  4. 谨慎使用友元以保持封装性：过度使用友元可能会导致类的内部实现过多地暴露给外部，从而破坏封装性。应当在确实需要的时候才使用友元。

  5. 模板中的友元关系复杂性：在模板编程中使用友元关系时，代码的复杂性可能增加，特别是在涉及模板特化和模板实例化的情况下。确保友元关系正确建立需要精确控制模板的声明和定义。

  6. 友元声明不能被继承：派生类不会自动继承基类的友元声明。如果需要在派生类中保持相同的访问权限，必须在派生类中重新声明友元。

  7. 注意模板的实例化时机：在使用模板友元时，确保模板在被引用之前正确地声明和定义是关键。错误的声明顺序可能导致编译错误或者友元关系未按预期工作。

  8. 友元声明中不能使用模板参数作为默认参数：在声明友元函数时，不能使用类模板的参数作为友元函数参数的默认值。这是因为友元函数本身并不是类模板的一部分，而是一个独立的实体。

不是仙人的闲人
关注
专栏目录
（C++）函数模板与类模板基础知识
Lemon_CHA的博客
09-10 311
目录一、模板的概念二、函数模板 一、模板的概念 模板就是建立通用的模具，大大提高复用性。 二、函数模板
c++ 友元模板类的定义
少帅的天空
04-12 5850
友元概念就不罗嗦了，使用也简单，就两种形式：1.友元函数：friend ret-type classname::funname(....);2.友元类：friend class classname;唯一要注意的就是不管是友元函数还是友元类，定义友元关系前必须先声明友元类其实还是有些故事要说的，一旦类继承起来友元关系还是有些小复杂的，下面简单说明：C中声明A是其友元类，那么最基本的就是A可以使用C中
c++模板友元函数 友元类
04-11
关于c+模板之友元类友元函数的实例化，图形界面之矩形。
C++ - 类模板(class template)友元(friend) 的 全部六种形式 及 代码
weixin_34409703的博客
11-24 880
类模板(class template)友元(friend) 的 全部六种形式 及 代码 版权所有, 禁止转载, 如有需要, 请站内联系; 本文地址: http://blog.csdn.net/caroline_wendy/article/details/16916441 类模板(class template)的友元(friend)和普通类的友元, 有很多...
C++的模板类和友元
little_startoo的博客
05-24 432
C++的模板类和友元
c++ 友元
weixin_33728268的博客
06-29 62
利用工作之余， 看了一天的友元居然都不理解， 第二天中午睡觉醒来后， 奇迹般的懂了， 把代码记录下来以防以后不懂    作用及特点 作用及特点   友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密...
C++友元
jia_xiaoxin的专栏
09-30 3333
1，friend申明一个友元friend一般为一句申明式，它位于一个类的内部，它申明一个类或者一个函数为该类的友元。friend并不是定义一个成员函数，所以friend放在public,protected或者private前都可以，完全是一样的。做为一个友元，即表示在该类或者该函数内部可以访问这个类的私有成员，你和朋友之间是不是应该没有什么隐藏的呢。例子：class A{public:
C++程序设计教程——设计思想与实现习题代码答案
12-07
资源中的习题代码答案覆盖了多个章节，包括从基础知识到高级特性的各个部分，如ch02、ch03、ch04、ch05、ch06、ch07、ch08和ch09。 在C++的学习过程中，掌握基本语法和数据类型是至关重要的。例如，`ch02`可能涉及...
c++面试基础知识点，基础知识点
最新发布
03-13
在C++面试中，基础知识是每个求职者必备的素质。以下是对标题和描述中提到的知识点的详细解析： 1. **编译内存**： 编译内存涉及到程序在内存中的布局，包括栈区（局部变量）、堆区（动态分配的内存）、常量区...
C++基础知识总结（详解）
weixin_44404541的博客
04-12 2360
C++超详细基础知识，有代码演示 一篇就包含C++的所有知识
C++学习教程从零开始（十一）（中）-类的相关知识共14
10-29
在本节"C++学习教程从零开始（十一）（中）——类的相关知识"中，我们将深入探讨C++中的核心概念之一：类。类是面向对象编程的基础，它定义了一组相关的属性（数据成员）和行为（成员函数），用于封装数据和功能。...
C++ 友元
weixin_30502965的博客
09-20 106
友元 友元 英文 friend。friend 翻译成中文就是朋友，翻译成术语就是：友元。朋友就很好理解了，我的钱你随便花，我的东西你随便用；当然我也是你的朋友，你的钱我随便花，你的东西我随便用。 当然在 C++ 里，类与类 之间可以作为友元，那么这个类就可以去操作另外一个类里面私有的成员；函数与函数 之间也可以作为 友元，所以友元分为： 友元函数 和 友元类。 我们通过一...
C++中模板类使用友元模板函数
squarereal的专栏
09-22 2113
问题始于学习数据结构，自己编写一个单链表，其中用到了重载输出运算符template class List{    friend std::ostream& operator & slist);    //……};用vs2008可编译，但无法链接：无法解析的外部符号……后来上网查改为template class List{    friend std::ostream& operator
C++类模板与友元函数
qq_54169998的博客
10-28 866
目录 1.普通全局函数做类模板的友元函数 2.运算符重载做类模板的友元函数 1.普通全局函数做类模板的友元函数 需求：现有demo类模板，要求使用自定义addFun函数，实现对两个demo对象的相加 demo.h #pragma once #include<ostream> #include<iostream> using namespace std; template <typename T> class A{ public: A(T t =
C++模板类和友元
Jasmine-Lily的博客
11-23 830
C++模板类和友元
友元模板
fdcumt的专栏
07-22 913
十、友元和类模板 1、类模板中有普通友元函数，友元类，模板友元函数和友元类，普通友元函数和友元类不做介绍。 2、可以建立两种类模板的友元模板，即约束型的友元模板和非约束型的友元模板。 3、非约束型友元模板：即类模板的友元模板类或者友元模板函数的任一实例都是外围类的任一实例的友元，也就是外围类和友元模板类或友元模板函数之间是多对多的关系 4、约束型友元模板：即类模板的友元模板类或
C++类模板与友元 类模板与友元 友元和类模板
qq_36711295的博客
08-12 447
C++类模板与友元 类模板与友元 友元和类模板 学习目标： 掌握类模板配合友元函数的类内和类外实现 全局函数类内实现 - 直接在类内声明友元即可 全局函数类外实现 - 需要提前让编译器知道全局函数的存在 #include <iostream> #include <string> using namespace std; //提前要进行声明类 //2.全局函数配合友元 类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元 template<class T1, cl
类模板的友元
oorik的博客
01-16 482
写之前给不知道友元的小伙伴说一声：友元不受public/private影响，他只是定义在类外部的普通函数或类，可以访问类中private成员；友元声明只能出现在类定义中 ，在外面去定义实现。C++的泛型编程真的是复杂，最近再看一些代码的时候涉及一些模板相关的地方，有的写法因为自己没咋用过看着就很陌生，这节就聊聊类模板的友元的各个形式写法。有关模板的文章之前写过一个可变参数的，感兴趣的可以看看。这是一个普通类的写法。
C++实验报告：面向对象程序设计——类与对象探索
"本次实验是面向对象程序设计的实验二，主要关注C++语言的类与对象相关的概念和使用。...通过对这些知识点的深入理解和实践，学生将能更好地掌握C++面向对象编程的基础，为后续的高级概念学习打下坚实基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值