c++复习2.模板（实验六、实验七）

已于 2024-01-02 18:21:53 修改 · 1.1k 阅读 · 16
文章标签：

#c++ #算法 #开发语言

于 2024-01-01 11:50:30 首次发布
该博客围绕C++的模板展开实验。实验六聚焦函数模板和类模板，包括其定义、使用及模板类实例化方法，并给出相关代码示例。实验七则探讨模板的特化和偏特化，涵盖函数模板全特化、类模板全特化与偏特化（参数数量和范围上），均有对应代码及运行结果要求。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言：类模板和模板类的区别

实验六 函数模板和类模板

一．实验目的

1.理解并掌握函数模板的定义和使用方法；

2.理解并掌握类模板的定义和使用方法；

3.理解并掌握模板类的应用和实例化方法；

二. 实验内容

1. 理解并掌握函数模板的定义和使用方法

第1题：请按照下面程序主函数的调用情况，定义一个加法运算的函数模板，按照注释要求完善程序。

#include <iostream>

using namespace std;

//定义加法运算函数模板

int main()

{

int x = 12;

float y = 46.9;

//cout << add(x, y) << endl;   //error，无法自动推导函数返回值

    cout << add<float>(x, y) << endl;    //返回值在第一个类型参数中指定

    cout << add<int, int, float>(x, y) << endl;

    return 0;

}

请给出完整程序的源代码，并粘贴运行结果。

#include <iostream>
using namespace std;

// 定义加法运算函数模板
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int x = 12;
    float y = 46.9;

    cout << add(x, static_cast<int>(y)) << endl;  // 显式指定模板参数
    cout << add<float>(x, y) << endl;  // 返回值在第一个类型参数中指定

    return 0;
}

2.理解并掌握类模板的定义和使用方法

第2题：定义一个矩形类模板 ，模板类中的数据成员为矩形的长和宽，其成员函数实现计算矩形的周长和面积。
 

#include <iostream>

using namespace std;

/* 定义一个矩形类模板Rect

成员函数：calcArea()、calePerimeter()

数据成员：m_length、m_height

 */

//请完成矩形类的定义

int main(void)

{

    Rect<int> rect(3, 6);

    cout <<"面积为：" <<rect.calcArea() << endl;

    cout << "周长为："<<rect.calePerimeter() << endl;    return 0;

}

请给出完整程序的源代码，并粘贴运行结果。

#include <iostream>
using namespace std;

// 定义一个矩形类模板Rect
template <typename T>
class Rect {
private:
    T m_length;
    T m_height;

public:
    Rect(T length, T height) : m_length(length), m_height(height) {}

    // 计算矩形的面积
    T calcArea() {
        return m_length * m_height;
    }

    // 计算矩形的周长
    T calePerimeter() {
        return 2 * (m_length + m_height);
    }
};

int main(void) {
    Rect<int> rect(3, 6);
    cout <<"面积为：" <<rect.calcArea() << endl;
    cout << "周长为："<<rect.calePerimeter() << endl;
    return 0;
}

3.理解并掌握模板类的应用和实例化方法

第3题：阅读下列关于数组类模板的定义和程序运行结果，按照注释要求补充类模板定义中相应的功能代码，以完成主函数对模板类数组的实例化调用。

#ifndef ARRAY_H_

#define ARRAY_H_

#include <cassert>

template <class T>

class Array {

private:

   T* list;

   int size;

public:

   Array(int sz = 50);

   Array(const Array<T>& a);

   ~Array();

   Array<T>& operator = (const Array<T>& rhs);

   T& operator[] (int i);

   const T& operator[] (int i) const;

   operator T* ();

   operator const T* () const;

   int getSize() const;

   void resize(int sz);

};

template <class T>

Array<T>::Array(int sz) {

   assert(sz > 0);

   size = sz;

   list = new T[size];

}

template <class T>

Array<T>::~Array() {

   delete [] list;

}

//下面补充类模板中其它成员函数声明的实现：

#endif  //ARRAY_H_

//以上为array.h头文件

#include <iostream>

#include <iomanip>

#include "array.h"

using namespace std;

void read(int *p, int n) {

 for (int i = 0; i < n; i++){

  cout << "请输入第" << i+1 <<"位学生的课程A成绩(0~100)：";

cin >> p[i];

}

}

double calculate(int *p, int n) {

double total=0;

 for (int i = 0; i < n; i++)

   total += p[i];

cout << n <<"位学生的总课程为：" << total;

return total;

}

int main()

{

   int n;

   double average = 0;

   cout << "请输入学生人数：";

   cin >> n;

Array<float>  score(n);

read(score, n) ;

average = calculate(score, n)/n;

cout <<n<< "位同学的平均成绩为：" << setprecision(4) << average << endl;

return 0;

}

简而言之，就是要写以下的模板：

   Array<T>& operator = (const Array<T>& rhs);

   T& operator[] (int i);

   const T& operator[] (int i) const;

   operator T* ();

   operator const T* () const;

   int getSize() const;

   void resize(int sz);

我写的补充部分的代码：

template <class T>
Array<T>& Array<T>::operator=(const Array<T>& rhs) {
    if (this == &rhs) {
        return *this;
    }
    delete [] list;
    size = rhs.size;
    list = new T[size];
    for (int i = 0; i < size; ++i) {
        list[i] = rhs.list[i];
    }
    return *this;
}

template <class T>
T& Array<T>::operator[](int i) {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
const T& Array<T>::operator[](int i) const {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
Array<T>::Array(const Array<T>& a) {
    size = a.size;
    list = new T[size];
    for (int i = 0; i < size; ++i) {
        list[i] = a.list[i];
    }
}

template <class T>
Array<T>::operator T* () {
    return list;
}

template <class T>
Array<T>::operator const T* () const {
    return list;
}

template <class T>
int Array<T>::getSize() const {
    return size;
}

template <class T>
void Array<T>::resize(int sz) {
    assert(sz > 0);
    if (sz == size) {
        return;
    }
    T* newList = new T[sz];
    int n = (sz < size) ? sz : size;
    for (int i = 0; i < n; ++i) {
        newList[i] = list[i];
    }
    delete [] list;
    list = newList;
    size = sz;
}

参考答案：

template <class T>
Array<T>::Array(const Array<T>& a) {
    size = a.size;
    list = new T[size];
    for (int i = 0; i < size; ++i) {
        list[i] = a.list[i];
    }
}

template <class T>
Array<T>& Array<T>::operator=(const Array<T>& rhs) {
    if (&rhs != this) {
        if (size != rhs.size) {
            delete [] list;
            size = rhs.size;
            list = new T[size];
        }
        for (int i = 0; i < size; ++i) {
            list[i] = rhs.list[i];
        }
    }
    return *this;
}

template <class T>
T& Array<T>::operator[](int i) {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
const T& Array<T>::operator[](int i) const {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
Array<T>::operator T*() {
    return list;
}

template <class T>
Array<T>::operator const T*() const {
    return list;
}

template <class T>
int Array<T>::getSize() const {
    return size;
}

template <class T>
void Array<T>::resize(int sz) {
    assert(sz >= 0);

    if (sz == size)
        return;

    T* newList = new T[sz];
    int n = (sz < size) ? sz : size;
    for (int i = 0; i < n; ++i) {
        newList[i] = list[i];
    }
    delete[] list;
    list = newList;
    size = sz;
}

参考答案完整源代码：

#ifndef ARRAY_H_
#define ARRAY_H_

#include <cassert>

template <class T>
class Array {
private:
    T* list;
    int size;
public:
    Array(int sz = 50);
    Array(const Array<T>& a);
    ~Array();
    Array<T>& operator = (const Array<T>& rhs);
    T& operator[] (int i);
    const T& operator[] (int i) const;
    operator T* ();
    operator const T* () const;
    int getSize() const;
    void resize(int sz);
};

template <class T>
Array<T>::Array(int sz) {
    assert(sz > 0);
    size = sz;
    list = new T[size];
}

template <class T>
Array<T>::~Array() {
    delete [] list;
}

template <class T>
Array<T>::Array(const Array<T>& a) {
    size = a.size;
    list = new T[size];
    for (int i = 0; i < size; ++i) {
        list[i] = a.list[i];
    }
}

template <class T>
Array<T>& Array<T>::operator=(const Array<T>& rhs) {
    if (&rhs != this) {
        if (size != rhs.size) {
            delete [] list;
            size = rhs.size;
            list = new T[size];
        }
        for (int i = 0; i < size; ++i) {
            list[i] = rhs.list[i];
        }
    }
    return *this;
}

template <class T>
T& Array<T>::operator[](int i) {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
const T& Array<T>::operator[](int i) const {
    assert(i >= 0 && i < size);
    return list[i];
}

template <class T>
Array<T>::operator T*() {
    return list;
}

template <class T>
Array<T>::operator const T*() const {
    return list;
}

template <class T>
int Array<T>::getSize() const {
    return size;
}

template <class T>
void Array<T>::resize(int sz) {
    assert(sz >= 0);

    if (sz == size)
        return;

    T* newList = new T[sz];
    int n = (sz < size) ? sz : size;
    for (int i = 0; i < n; ++i) {
        newList[i] = list[i];
    }
    delete[] list;
    list = newList;
    size = sz;
}

#endif  // ARRAY_H_

#include <iostream>
#include <iomanip>

using namespace std;

template<typename T>
void read(Array<T>& p, int n) {
    for (int i = 0; i < n; i++) {
        cout << "请输入第" << i + 1 << "位学生的课程A成绩(0~100)：";
        cin >> p[i];
    }
}

template<typename T>
double calculate(Array<T>& p, int n) {
    double total = 0;
    for (int i = 0; i < n; i++)
        total += p[i];
    cout << n << "位学生的总课程为：" << total;
    return total;
}

int main() {
    int n;
    double average = 0;
    cout << "请输入学生人数：";
    cin >> n;
    Array<float> score(n);
    read(score, n);
    average = calculate(score, n) / n;
    cout << n << "位同学的平均成绩为：" << setprecision(4) << average << endl;
	return 0;
}

实验七 模板的特化和偏特化

一．实验目的

1.理解并掌握函数模板全特化的定义和使用方法；

2.理解并掌握类模板特化和偏特化的定义和使用方法；

二. 实验内容

1. 理解并掌握函数模板全特化的定义和使用方法

第1题：请根据下面程序主函数的调用情况和程序运行结果，定义相应的全特化函数模板，按照注释要求完善程序,给出程序源代码及程序运行结果截图。

//template.h

#pragma once

#include <iostream>

template <typename T, typename U>

void tfunc(T& a, U& b)

{

    std::cout << "tfunc 泛化版本函数" << std::endl;

}

// 补充相应的函数全特化代码

//main.cpp

#include <iostream>

#include "template.h"

using namespace std;

int main()

{

    int a1 = 1;

    double b1 = 3.2;

    tfunc(a1, b1);

    tfunc(a1, a1);

}

//template.h
#pragma once
#include <iostream>
template <typename T, typename U>
void tfunc(T& a, U& b)
{
	std::cout << "tfunc 泛化版本函数" << std::endl;
}
// 补充相应的函数全特化代码


//// 函数全特化1
//template <>
//void tfunc(int& a, double& b)
//{
//    std::cout << "tfunc 全特化版本函数1" << std::endl;
//}

// 函数全特化2
template <>
void tfunc(int& a, int& b)
{
    std::cout << "tfunc 全特化版本函数2" << std::endl;
}

//main.cpp
#include <iostream>
#include "template.h"
using namespace std;
int main()
{
	int a1 = 1;
	double b1 = 3.2;
	tfunc(a1, b1);
	tfunc(a1, a1);
}

运行结果截图：

2. 理解并掌握类模板全特化的定义和使用方法

第2题：请根据下面程序主函数的调用情况和程序运行结果，定义一个相应的全特化函数模板，按照注释要求完善程序,给出程序源代码及程序运行结果截图。

//template.h

#pragma once

#include <iostream>

template <typename T, typename U>

class TC

{

public:

    TC()

    {

        std::cout << "泛化版本构造函数" << std::endl;

    }

    void funtest()

    {

        std::cout << "泛化版本成员函数" << std::endl;

    }

};

// 补充相应的类全特化代码

//main.cpp

#include <iostream>

#include "template.h"

using namespace std;

int main()

{

    TC<char, int> tchar;

    tchar.funtest();

    TC<int, int> tint;

    tint.funtest();

    TC<double, double> tdouble;

    tdouble.funtest();

}

//template.h
#pragma once
#include <iostream>
template <typename T, typename U>
class TC
{
public:
	TC()
	{
		std::cout << "泛化版本构造函数" << std::endl;
	}
	void funtest()
	{
		std::cout << "泛化版本成员函数" << std::endl;
	}
};


template <>
class TC<int, int>
{
public:
	TC()
	{
		std::cout << "TC<int, int> 全特化版本构造函数" << std::endl;
	}
	void funtest()
	{
		std::cout << "TC<int, int> 全特化版本成员函数" << std::endl;
	}
};


template <>
class TC<double, double>
{
public:
	TC()
	{
		std::cout << "TC<double, double> 全特化版本构造函数" << std::endl;
	}
	void funtest()
	{
		std::cout << "TC<double, double> 全特化版本成员函数" << std::endl;
	}
};

//main.cpp
#include <iostream>
#include "template.h"
using namespace std;

int main()
{
	TC<char, int> tchar;
	tchar.funtest();
	TC<int, int> tint;
	tint.funtest();
	TC<double, double> tdouble;
	tdouble.funtest();
}

程序运行结果截图：

3. 理解并掌握类模板偏特化的定义和使用方法

（1）类模板参数数量上的偏特化

第3题：请根据下面程序主函数的调用情况和程序运行结果，定义一个相应的偏特化类模板，按照注释要求完善程序,给出程序源代码及程序运行结果截图。

//template.h

#pragma once

#include <iostream>

template <typename T, typename U, typename W>

class TC2

{

public:

    void funtest()

    {

        std::cout << "泛化版本成员函数" << std::endl;

    }

};

// 补充相应的类偏特化代码

//main.cpp

#include <iostream>

#include "template.h"

using namespace std;

int main()

{

    TC2<double, double, double> tdouble2;

    tdouble2.funtest();

    TC2<int, double, double> tint2;

    tint2.funtest();

}

//template.h
#pragma once
#include <iostream>
template <typename T, typename U, typename W>
class TC2
{
public:
	void funtest()
	{
		std::cout << "泛化版本成员函数" << std::endl;
	}
};


template <typename U>
class TC2 <int, U, double>
{
public:
	void funtest()
	{
		std::cout << "TC2 <int, U, double> 偏特化版本成员函数" << std::endl;
	}
};

//main.cpp
#include <iostream>
#include "template.h"
using namespace std;

int main()
{
	TC2<double, double, double> tdouble2;
	tdouble2.funtest();
	TC2<int, double, double> tint2;
	tint2.funtest();
}

运行结果截图：

（2）类模板参数范围上的偏特化

第4题：请根据下面程序主函数的调用情况和程序运行结果，定义一个相应的偏特化类模板，按照注释要求完善程序,给出程序源代码及程序运行结果截图。

// template.h

#pragma once

#include <iostream>

template <typename T>

class TC3

{

public:

    void funtest()

    {

        std::cout << "泛化版本成员函数" << std::endl;

    }

};

// 补充相应的类偏特化代码

//main.cpp

#include <iostream>

#include "template.h"

using namespace std;

int main()

{

    TC3<int> tint3;

    tint3.funtest();

    TC3<int&> tint3_ref;

    tint3_ref.funtest();

    TC3<int*> tint3_point;

    tint3_point.funtest();

    TC3<const int> tint3_const;

    tint3_const.funtest();

}

运行结果截图：

// template.h
#pragma once
#include <iostream>
template <typename T>
class TC3
{
public:
	void funtest()
	{
		std::cout << "泛化版本成员函数" << std::endl;
	}
};


template <typename T>
class TC3<T&>
{
public:
	void funtest()
	{
		std::cout << "T&偏特化版本成员函数" << std::endl;
	}
};


template <typename T>
class TC3<T*>
{
public:
	void funtest()
	{
		std::cout << "T*偏特化版本成员函数" << std::endl;
	}
};

template <typename T>
class TC3<const T>
{
public:
	void funtest()
	{
		std::cout << "const T偏特化版本成员函数" << std::endl;
	}
};

//main.cpp
#include <iostream>
#include "template.h"
using namespace std;

int main()
{
	TC3<int> tint3;
	tint3.funtest();
	TC3<int&> tint3_ref;
	tint3_ref.funtest();
	TC3<int*> tint3_point;
	tint3_point.funtest();
	TC3<const int> tint3_const;
	tint3_const.funtest();
}

运行结果截图：

实验7 IO流
BigBen的专栏
05-18 2421
1. 实验目的和要求 (1) 理解I/ O流与标准流对象的意义，掌握文件的基本操作 (2) 掌握常用的IO 成员函数：正确打开关闭文件，检测流状态并进行顺序读写操作。 (3) 了解文件的随机读写方法，理解二进制文件与文本文件的区别 2. 实验内容： 1、 建立用户自定义复数类Complex，类中包括private整数数据成员real和imaginary，重载流插入和流读取运算符实现输入输
C++复习(秋).doc
05-09
C++是一种静态类型、编译式、通用的编程语言，由Bjarne Stroustrup在1979年在贝尔实验室开始设计开发。最初被称为C with Classes，其设计初衷是为支持数据抽象和面向对象编程的C语言扩展。由于其强大的功能和灵活性...
C++实验7 I/O流基础
attack_5的博客
11-12 1343
一、实验目的和要求  1．熟悉流类库中常用的类及其成员函数的用法。 2．学习标准的输入输出及格式控制。 3．学习对文件的应用方法 二、实验环境（软、硬件及条件） 一台安装有Visual C++ 6.0的计算机 三、实验步骤 1．写出下列程序的运行结果。 #include "iostream.h" ...
实验7 I/O 多路复用
weixin_34019144的博客
07-02 171
实验7I/O 多路复用1 要掌握的数据类型文件描述符集合fd_set利用宏FD_ZERO(&rset)初始化利用宏FD_SET(sockfd,&rset)将sockfd 加入到rset 中利用宏FD_CLR(sockfd,&rset)将sockfd 从rset 中删除利用宏FD_ISSET(sockfd,&rset)判定sockfd 是否在rs...
C++（7）——函数模板和类模板
青布衫白少年的博客
08-11 482
函数模板 模板是实现代码重用机制的一种工具，它可以实现类型参数化， 即把类型定义为参数，从而实现了真正的代码可重用性。模板可以分为两类：一个是函数模板，一个是类模板。 函数模板 <>内是函数模板参数列表 模板实例化:在调用点用具体类型替换虚假类型 没有模板的实例化，模板中的错误无法发现 函数模板不编译（永远不编译） 函数模板的编译 1、定义点 编译模板的头部 2、调用点 编译模板实例化后的产物 ==》模板函数才是要被编译器所编译的 模板的实参推演=》可以根据用户传入的实参类型，来推导出模板类型参
算法设计与分析2023秋-头歌实验-实验七 动态规划
杨明金的博客
12-18 5785
本关任务：编写用动态规划解决数塔问题。
c++复习1.泛型编程、STL标准模板库（实验八）
xuge520的博客
01-01 1059
第1题：请仿造STL中Accumulate算法的定义方法，完成下列任务：附：源码定义、使用示例及TEMPLATEaccumulate源码的定义、使用示例：定义、使用示例//两个同类型变量相乘是乘法的二元函数对象常被用于或者等的运算算子。//TEMPLATEmultiplies使用示例usingnamespacestd;
SCAU期末C++复习实验六
m0_74222809的博客
07-02 590
第请按照下面程序主函数的调用情况，定义一个加法运算的函数模板，按照注释要求完善程序。//定义加法运算函数模板int main()//error，无法自动推导函数返回值//返回值在第一个类型参数中指定return 0;请给出完整程序的源代码，并粘贴运行结果。T1 sum;return sum;//error，无法自动推导函数返回值//返回值在第一个类型参数中指定//值为58return 0;
东南大学C++课程课后实验.zip
06-01
2. **Lab1 - Lab9**: 这些实验室实验的具体内容，每个实验通常包括一个或多个小任务，涉及C++的不同方面。例如： - **Lab1**：可能涵盖C++的基础语法，如变量声明、数据类型、运算符、流程控制（if、switch、for、...
C++程序设计 实验报告模板.doc
06-13
**C++程序设计实验报告模板** 实验报告是学习C++编程过程中不可或缺的一部分，它旨在帮助学生深入理解编程概念，提高分析问题和解决问题的能力。通过撰写实验报告，学生能够回顾实验过程，总结经验，并对所学知识...
大学生c++上机实验实验一.docx答案
04-29
"大学生c++上机实验实验一" 该实验的目的是让学生复习C语言的内容，熟悉C++中简单的标准输入输出函数的使用，理解内置函数的优缺点，学会使用内置函数，理解和使用函数重载以及带默认参数的函数，理解和使用引用。 ...
C++复习题及答案.docx
02-27
根据提供的文件信息：“C++复习题及答案.docx”，我们可以推断这份文档主要涉及的是C++编程语言的相关复习题目及其解答。C++是一种通用、面向对象的编程语言，由Bjarne Stroustrup在贝尔实验室开发，最初作为C语言的...
MVCC底层实现原理
码码哈哈的博客
08-13 356
MVCC（多版本并发控制）是InnoDB实现高并发的核心机制。其底层原理包括：1）存储结构上，每行记录包含3个隐藏列（事务ID、回滚指针、行ID）和Undo Log；2）通过回滚指针形成版本链，保留历史数据；3）ReadView机制基于事务ID和活跃事务列表判断数据可见性，实现快照隔离；4）不同隔离级别下ReadView生成策略不同；5）Purge线程清理过期版本。MVCC在保证事务隔离性的同时，显著提升了数据库并发性能。（149字）
c++ 常见关键字
u012719076的博客
08-11 511
override 子类种重写父类中函数，，仅用于派生类虚函数，强制检查重写正确性。final 防止子类继承，用于类或虚函数，限制继承或重写。c++ 函数模板、类模板-优快云博客。四、template 模板。
C++ std::list 深度剖析：实现原理与性能优化
liulilittle的博客
08-12 778
📌 C++ std::list 技术摘要 std::list 是C++ STL基于双向链表实现的容器，核心特性包括： 循环双向链表结构：通过哨兵节点连接首尾，每个节点包含前后指针和数据 内存开销显著：每个节点额外16字节指针开销，小型数据存储效率低 历史性能陷阱：C++03中size()为O(n)操作，C++11后优化为O(1) 内存碎片问题：频繁节点分配导致碎片化，可通过自定义内存池分配器优化 最佳实践： 优先使用empty()而非size()判断空列表 大型对象存储时选用list更合理 高频操作场景考
C++ 学习与 CLion 使用：（二）using namespace std 语句详解，以及 std 空间的标识符罗列
qq_51409113的博客
08-12 743
详细解释了 using namespace std 语句，并且尽可能地罗列了所有的 std 标识符
gRPC for C++ 实战全流程 —— 从零搭建到同步/异步服务
人心有反复，好在山水有重逢。
08-09 461
定义了两个 RPC 接口：注册和登录。状态中创建新对象以处理后续请求。实现，有两种封装方式。
C语言：构造类型
2301_77829391的博客
08-10 679
*定义：**自定义数据类型的一种，关键字struct。struct 结构体名 // 结构体名：自定义的数据类型名字 类似于int,double之类的数据类型1 成员名称1;// 结构体中的变量叫做成员数据类型2 成员名称2;...注意：结构体中定义的变量，称之为成员变量（成员属性）结构体名：合法的标识符，建议首字母大写（所谓的结构体名，就是自定义类型的类型名称）数据类型n：C语言支持的所有类型（包括函数，函数在这里用函数指针表示）成员名称n：合法的表示，就是变量的命名标准。
C++ 类和对象4---(初始化列表,类型转化,static成员)
最新发布
2401_88465894的博客
08-13 834
本文深入讲解了C++中的三个重要特性：构造函数初始化列表、类型转换和static成员。初始化列表部分详细介绍了其语法、核心特性（如初始化时机、必须使用场景）和初始化逻辑，通过Date类示例展示了实际应用。类型转换部分重点分析了内置类型到类类型和类类型之间的隐式转换机制，包括语法形式、核心特性和explicit关键字的作用。static成员部分则阐述了静态成员变量（类外初始化、共享性）和静态成员函数（无this指针、类级访问）的特点和使用方法。全文通过丰富示例帮助读者理解这些核心概念的实际应用场景和注意事项。
C++实验指导：掌握程序设计的必备教程
【知识点】：C++程序设计实验指导 标题和描述中提到的文件是“C++程序设计实验指导.rar”，并且特别标注了文件格式为“.pdg”。这表明该文件是一个压缩包，其中包含了有关C++程序设计的实验指导内容。这里涉及的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值