【C++详解】类和对象（上）（访问限定符、封装、域、this指针）

最新推荐文章于 2024-06-20 08:38:53 发布
最新推荐文章于 2024-06-20 08:38:53 发布
阅读量439 收藏 2
点赞数
分类专栏： C++详解
❗ 转载请注明出处 作者：HinsCoder 博客链接：
本文链接：https://blog.csdn.net/HinsCoder/article/details/127169163
版权

📖 前言：本期我们将引入类和对象的概念，系统的介绍面向对象程序设计的魅力，它的出现开启了程序设计的新篇章。

目录

🕒 1. 面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 面向对象的三大特性：封装；继承

例子：
在这里插入图片描述

  • 展开解释一下：面向过程的思想就是，我不管这事情主角是谁，我就按事情的发展过程叙述。这个形式里强调描述“过程"。就好比编年体里，我会把1000年里每一年有什么事情发生罗列在一起，让你看完之后，对事情的过程很清晰，但每个人物都干过啥，理不清了。
  • 而面向对象思想是，我强调一件事情的“主角”是谁，所有和他相关的内容都封装在一起。就好比纪传体，一个人物单独封装成一个章节。这个封装里面，主角（对象）非常清晰，一切事情都是围绕它的。这个做法的好处是，你如果想查一查A是否干过B，你可以只查A那章内容就好了。
  • 简而言之就是，如果思考事情都从一个特定主角出发（比如写纪传体），那就是面向对象的。如果没有清晰的主角，那就是面向过程的。

🕒 2. 类的引入

  • 在C语言中其实我们已经了解过类的概念，本质就是C语言中的结构体
//使用结构体描述一个学生
struct Student
{
	char name[20];//姓名
	int age;//年龄
	char id[12];//学号
};
  • 但是上面这个“对象”，只有属性显得没有活力，一个完整的对象应该是具有行为（函数）的，而在C++中，因为面向对象的概念引入，C的结构体得以升级。所以创建了一种新的类型：类
//使用结构体描述一个学生
struct Student
{
	void Learn()
	{
		//如何学习……
	}
	void Eat()
	{
		//如何吃饭……
	}
	void Sleep()
	{
		//如何睡觉……
	}
	char name[20];//姓名
	int age;//年龄
	char id[12];//学号
};

本质： 类可以看作不同对象的集合【Eg：不同的学生，有着不同的姓名、身高、行为方式……但可以定义一个student类去表述出不同的学生】

类的构成：

  1. 类的属性：即类的成员变量
  2. 类的方法（行为）：即类的成员函数

简单来说：

  • C语言中，结构体中只能定义变量
  • 在C++中，结构体内不仅可以定义变量，也可以定义函数
  • 其中，我们更喜欢用class来代替struct

🕒 3. 类的定义

class className
{
	// 类体：由成员函数和成员变量组成
    
};  // 一定要注意后面的分号
  • class：为定义类的关键字
  • className：为类的名字
  • 类的主体：可由成员变量+成员函数组成

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

🕘 3.1 类的两种定义方式

  1. 声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
class Student
{
	void ShowStu()
	{
		cout << name << " " << age << " " << tele << endl;
	}
	char name[20];
	int age;
	char tele[12];
};
  1. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名:: （声明和定义分离）
class Student
{
	void ShowStu();	//显示基本信息

	char name[20];
	int age;
	char tele[12];
};

#include"student.h"

// 显示基本信息，实现：输出名字、年龄、电话
void Student::ShowStu()
{
	cout << name << " " << age << " " << tele << endl;
}

在这里插入图片描述
一般情况下，更期望采用第二种方式。声明和定义分离的目的就是增加代码的观赏性，在大工程中如果不这样的话，想看类中的成员变量，可能会由于内部函数代码过多导致花费的时间成本高，看起来极其复杂。需要注意的是，这样进行分离定义之后，缺省值不能同时在.h中定义，而是在.cpp中使用。

🕘 3.2 类定义的两个惯例

  1. 类的成员变量使用修饰符修饰 ：与C语言结构体不同，由于类中可以同时定义变量和函数，所以函数的形参与类成员变量就可能会发生冲突，这种情况在 Init 函数中十分常见，如下
class Date
{
public:
    void Init(int year)
    {
        // 这里的year到底是成员变量，还是函数形参？
        year = year;
    }
    private:
    int year;
};

Init 函数的形参和类成员变量相同，这就导致我们初始化赋值的不确定性，当然我们也可以使用类名+域作用限定符或者this指针（以后会提到）来解决这个问题：

void Init(int year)
{
    Date::year = year;
    //this->year = year;
}

但是这样显然比较麻烦，所以在C++中有一个惯例，成员变量使用某种修饰符来修饰，比如_member，mMenber等，具体看个人喜好与未来企业要求，这里采用_member的写法

class Date
{
public:
    void Init(int year)
    {
        _year = year;
    }
    private:
    int _year;
};
  1. 成员函数定义在成员变量前面：C语言编译器寻找变量的规则是先到前面去找，然后再到全局去找，所以在C语言中变量必须定义在函数前面，才可以在函数中使用该变量；但是C++编译器不一样，C++编译器会把类看作一个整体，当我们使用一个变量时，它会到整个类中去寻找，然后再到全局去寻找；所以在C++中，我们是可以将成员变量定义成员函数后面的；

上面解释了成员函数定义在成员变量之前的可行性，下面我借用 《高质量C/C++编程》中的解释来阐述为什么要将成员函数定义在成员变量前面：
在这里插入图片描述

🕒 4. 类的访问限定符及封装

🕘 4.1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
访问限定符有：public（公有）、protected（保护）、private（私有）

【访问限定符说明】

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问(现阶段可以认为protected和private是一样的)
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
  4. 如果后面没有访问限定符，作用域就到 } 即类结束。
  5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

【面试题】
问题：C++中struct和class的区别是什么？
解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，后续给大家介绍。

🕤 4.1.1 限定域与类的区别

我们知道，对于命名空间来说，有一个限定域的概念，并且通过::可以直接操作，但对于类，我们可不可以这样访问里面的成员变量呢？

class Student
{
public:
	void ShowStu()
	{
		cout << _name << " " << _age << " " << _tele << endl;
	}
	char _name[20];
	int _age;
	char _tele[12];
};

int main()
{
	Student::_age = 20;		//error
}

在这里插入图片描述
很明显不能，我们回顾下C语言时学习的struct类型

struct Student2	//类型
{
	char _name[20];	//声明
	int _age;
	char _tele[12];
};

声明是不会开辟空间的，定义才会开空间。声明就好比你的好朋友说在疯狂星期四要V你50，但是实际给你了吗？定义就是只有给你个承诺也就是拿到50块才实现了

正确的打开方式：new一个对象

int main()
{
	Student Alice;
	Alice._age = 20;
}

用类类型创建对象的过程，称为类的实例化
上面的代码中，Student类是没有空间的，只有Student类实例化出的对象才有具体的年龄。只有先定义一个对象，才能对其内部属性进行操作。
在这里插入图片描述
打个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

🕘 4.2 封装

面向对象的三大特性：封装、继承、多态。
【实际中不止三种特性，还有：抽象、反射（Java），但与上述三种相比较之下，上述的三种特性更为重要】

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

在这里插入图片描述

🕒 5. 类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用::作用域操作符指明成员属于哪个类域。

class Student
{
public:
    void ShowStu();
private:
    char _name[20];	//声明
    int _age;
    char _tele[12];
};
// 这里需要指定ShowStu是属于Student这个类域
void Student::ShowStu()
{
    cout << _name << " " << _age << " " << _tele << endl;
}

🕒 6. 类对象模型

🕘 6.1 类对象的大小

  • 类对象的大小的计算是遵循🔎 内存对齐的规则
  • 但现在有一个问题：类里包含了成员函数，成员函数的大小是否包含在类对象的大小中呢？
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	char _a;
};

int main()
{
	A aa;
	cout << sizeof(A) << endl;	// 输出：1
	cout << sizeof(aa) << endl;	// 输出：1
	return 0;
}

答案是否定的，一个类的大小只计算成员变量的大小（遵循内存对齐的规则），不计算成员函数的大小在内；对于"空类"的空间大小，只有1字节

⚡ 注意：成员函数真正存储的地方，并不是在类里面，而是在公共代码区；这样的好处是当多个对象调用成员函数时，并不会产生多份重复的成员函数，从而占用空间、浪费空间。

"空类"给1字节的原因是表示占位（即表示对象存在），如果都为0字节则会地址重合无法区分。

🕒 7. this 指针

🕘 7.1 this 指针的引出

我们先来定义一个日期类 Date

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	void Print()
	{
		cout << _year << "_" << _month << "_" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 10, 5);
	d2.Init(2022, 11, 11);
	d1.Print();
	d2.Print();
	return 0;
}

由上通过Date类创建了两个对象：d1、d2，但当对象都调用成员函数的时候，函数体内并没关于不同对象的区分，那成员函数是如何知道该设置哪个对象呢？

C++中通过引入this指针解决该问题，C++编译器给每个 “非静态的成员函数” 增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

🕘 7.2 this 指针的特性

  1. this指针的类型：类类型*const，即成员函数中，不能给this指针赋值。
const Date* p1
Date const* p2
Date* const p3

快问快答：以上代码中const修饰的是谁
答：第一个和第二个分别修饰的是p1和p2，第三个是p3

  1. 只能在“成员函数”的内部使用
  2. this指针本质上是“成员函数的“的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  3. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递，但如果强行加上this，编译器也就不会自动加了，这就是多此一举了。

在这里插入图片描述

【面试题】
this指针存在哪里？（栈、堆、静态区、常量区）
this指针可以为空吗？

答：一般是存放在栈帧中。我们通过前面的演示可以看见，this指针是存放在形参中的，因此，与函数的形参的保存位置一样。（vs下面进行了优化，使用ecx寄存器传递）
在这里插入图片描述
我们发现，在这里利用了ecx直接通过this指针（这里的this指针事实上就是转化成了d1)

对于第二个问题，我们来看看具体例子：

 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
void Print()
{
    cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
    A* p = nullptr;
    p->Print();
    return 0;
}

由于p为空指针，但是这里的p->Print();并不是解引用去访问，通过上面类对象的存储方式猜测我们知道，因为成员函数的地址不在对象中，而是在公共代码区域。通过this指针的知识可知，this指针为空指针，Print的参数就是一个空指针，但是Print函数的执行与this指针是否为空无关，因此，选项为C。

再看一个例子：

2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
    void PrintA()
    {
        cout<<_a<<endl;
    }
    private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

这个与第一个例子的差别只是在"Print()"和_a的区别，对于第二个，this指针当然也为空，由上面知识可知，_a是this->a，而this又是p（nullptr），于是这里出现了空指针的解引用，因此会运行崩溃，选项为B。

所以对于第二个问题，this指针不可以为空。
注：空指针是运行错误，编译是检查不出来的。（因此上述的空指针错误是运行错误。）

🕒 8. C语言和C++实现Stack的对比

  1. C语言实现
typedef int DataType;
typedef struct Stack
{
    DataType* array;
    int capacity;
    int size;
}Stack;
void StackInit(Stack* ps)
{
    assert(ps);
    ps->array = (DataType*)malloc(sizeof(DataType) * 3);
    if (NULL == ps->array)
    {
        assert(0);
        return;
    }
    ps->capacity = 3;
    ps->size = 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    if (ps->array)
    {
        free(ps->array);
        ps->array = NULL;
        ps->capacity = 0;
        ps->size = 0;
    }
}
void CheckCapacity(Stack* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity * 2;
        DataType* temp = (DataType*)realloc(ps->array,
                          newcapacity*sizeof(DataType));
        if (temp == NULL)
        {
            perror("realloc申请空间失败!!!");
            return;
        }
        ps->array = temp;
        ps->capacity = newcapacity;
    }
}
void StackPush(Stack* ps, DataType data)
{
    assert(ps);
    CheckCapacity(ps);
    ps->array[ps->size] = data;
    ps->size++;
}
int StackEmpty(Stack* ps)
{
    assert(ps);
    return 0 == ps->size;
}
void StackPop(Stack* ps)
{
    if (StackEmpty(ps))
        return;
    ps->size--;
}
DataType StackTop(Stack* ps)
{
    assert(!StackEmpty(ps));
    return ps->array[ps->size - 1];    
}
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->size;
}
int main()
{
    Stack s;
    StackInit(&s);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackPop(&s);
    StackPop(&s);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackDestroy(&s);
    return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

  • 每个函数的第一个参数都是Stack*
  • 函数中必须要对第一个参数检测，因为该参数可能会为NULL
  • 函数中都是通过Stack*参数操作栈的
  • 调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

  1. C++实现
typedef int DataType;
class Stack
{
public:
    void Init()
    {
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = 3;
        _size = 0;
    }
    void Push(DataType data)
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    void Pop()
    {
        if (Empty())
            return;
        _size--;
    }
    DataType Top(){ return _array[_size - 1];}
    int Empty() { return 0 == _size;}
    int Size(){ return _size;}
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
    private:
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType* temp = (DataType*)realloc(_array, newcapacity *
                              sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Pop();
    s.Pop();
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();
    return 0;
}

C++中通过类可以将数据 以及 操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *参数是编译器维护的，C语言中需用用户自己维护。

OK，以上就是本期知识点“类和对象（上）”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~
💫如果有错误❌，欢迎批评指正呀👀~让我们一起相互进步🚀
🎉如果觉得收获满满，可以点点赞👍支持一下哟~

HinsCoder
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++：类和对象（上篇---概念、定义、访问限定符、封装、类的大小、this指针）
ETalien_的博客
02-24 292
类和对象（上篇—概念及定义） C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。 一、类和对象概念 1.类： 类是现实世界在计算机中的反映，它将数据（成员变量）和对这些数据的操作（成员函数）...
c++类/类的作用域/类的访问限定符及封装/类的实体化/类对象模型/this指针详解
aaaaauaan的博客
07-31 856
1.面向过程和面向对象初步认识 面向过程：C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。其中对小程序的解决还是可以的，但缺点是不适合开发大的应用程序，而且对于程序的维护较差，某一小步出错的话，维护起来比较麻烦。 面向过程：C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 简单来说，C++中结构体（在C++中称为类）可以用来描述对象的属性信息 + 定义对象的所具有的功能 == 一个对象。 2.类的引入 C语言中，结构体中只能定义变量，
史上最全关于C++类和对象详解
无梦_相赠的博客
06-03 1820
史上最全的C++面向对象详解博客,能换读者一个收藏吧?
C++ 类和对象详解
叫我小秦就好了的博客
03-26 2874
文章介绍类的基本内容，并对this 指针、默认成员函数、赋值运算符重载、const 成员和 static 成员展开重点讲解。
从0开始C++（四）：作用域限定符、this指针、static与const关键字详解
当实力撑不起野心的时候 学习才是唯一出路
06-20 1599
2、引用嵌套命名空间中的变量或函数：如果在命名空间的内部定义了与外部命名空间同名的变量或函数，可以使用作用域解析运算符来引用外部命名空间中的变量或函数。const可以应用于变量、函数参数、函数返回值等。3、引用类的静态成员：如果在类的内部定义了静态成员变量或静态成员函数，可以使用类名加上作用域解析运算符来引用类的静态成员。使用this指针可以明确指示当前对象的地址，可以解决对象之间的命名冲突问题，同时也方便了对对象的成员变量和成员函数的操作。它可以在类的成员函数中使用，用于引用调用该成员函数的对象的地址。
详解C++编程中类的声明和对象成员的引用
01-20
C++编程中，类（Class）是面向对象编程的基础，它定义了一种自定义的数据类型，可以用来封装数据和操作这些数据的函数。类的声明是创建类的蓝图，它描述了类的结构，包括成员变量（数据成员）和成员函数（方法）。类...
C/C++静态类和this指针详解及实例代码
08-31
C/C++中的静态类和this指针是编程中非常重要的概念，它们涉及到类的成员访问权限和对象的内部操作。 静态类在C++中是指含有静态成员的类。静态成员的特点是可以被所有类的实例共享，不需要通过特定的对象来访问。...
详解C++中的this指针与常对象
09-03
总结来说，`this`指针是C++中用于访问和操作对象成员的关键工具，而常对象则提供了防止对象状态改变的保护机制。理解`this`和常对象的概念对于深入学习C++的面向对象编程至关重要，它们能够帮助编写更加安全、高效的...
华为智慧城市成功案例集
08-29
华为智慧城市成功案例集
小程序-仁怀酱酒宝：酒类商城模板（源码）.zip
最新发布
08-29
小程序-仁怀酱酒宝：酒类商城模板（源码）.zip
剑雅真题G类雅思官方指南OG剑雅真题G类雅思官方指南OG
08-29
剑雅真题G类雅思官方指南OG剑雅真题G类雅思官方指南OG提取方式是百度网盘分享地址
基于微信小程序的点餐系统的设计设计与实现.docx
08-29
基于微信小程序的点餐系统的设计设计与实现.docx
lesson47-RNN原理.zip
08-29
深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT深度学习与PyTorch入门实战视频教程 配套源代码和PPT
机器学习知识教程.ppt
08-29
内容概要：本资源深入探讨了机器学习的基础概念、发展历程、学习系统的特点以及多种学习方法。通过具体的示例和算法案例，引导读者理解机器学习的核心原理和应用实践，涵盖了从机械式学习到基于解释的归纳学习等不同层次的学习策略。 适合人群：适合计算机科学、人工智能、数据科学等专业的在校学生，以及对机器学习感兴趣的研发人员和行业从业者。特别适合那些希望建立扎实机器学习理论基础并了解其应用的研究者和开发者。 能学到什么： 1. 机器学习的定义、重要性和在人工智能中的核心地位。 2. 机器学习的发展历史，包括热烈时期、冷静时期、复兴时期和蓬勃发展时期。 3. 机器学习系统的组成要素、特征和基本模型。 4. 机器学习的分类方法，包括按学习策略、知识表示方法和应用领域等。 5. 各种机器学习策略，如机械学习、传授学习、演绎学习、归纳学习、类比学习和基于解释的学习。 6. 双空间模型和变型空间法在示例学习中的应用，以及决策树算法的原理和构建过程。 阅读建议：此资源不仅涵盖了机器学习的基础理论知识，还包含了丰富的示例和练习，帮助读者更好地理解和掌握机器学习的关键概念和技术。在学习的过程中，建议读者结合实际
mt.exe
08-29
Windows 8 SDK 此 SDK 于 2012 年 11 月发布，可用于创建适用于 Windows 8 或更早版本的 Windows 应用 () 使用 Web 技术、本机和托管代码;或使用本机或托管编程模型的桌面应用。
九齐单片机 NY8-Example-Code 程序模板
08-29
九齐单片机 NY8_Example_Code 程序模板
RIIL产品普教校园解决方案（锐捷）PPT(30页).pptx
08-29
智慧校园建设方案旨在通过融合先进技术，如物联网、大数据、人工智能等，实现校园的智能化管理与服务。政策的推动和技术的成熟为智慧校园的发展提供了基础。该方案强调了数据的重要性，提出通过数据的整合、开放和共享，构建产学研资用联动的服务体系，以促进校园的精细化治理。 智慧校园的核心建设任务包括数据标准体系和应用标准体系的建设，以及信息化安全与等级保护的实施。方案提出了一站式服务大厅和移动校园的概念，通过整合校内外资源，实现资源共享平台和产教融合就业平台的建设。此外，校园大脑的构建是实现智慧校园的关键，它涉及到数据中心化、数据资产化和数据业务化，以数据驱动业务自动化和智能化。 技术应用方面，方案提出了物联网平台、5G网络、人工智能平台等新技术的融合应用，以打造多场景融合的智慧校园大脑。这包括智慧教室、智慧实验室、智慧图书馆、智慧党建等多领域的智能化应用，旨在提升教学、科研、管理和服务的效率和质量。 在实施层面，智慧校园建设需要统筹规划和分步实施，确保项目的可行性和有效性。方案提出了主题梳理、场景梳理和数据梳理的方法，以及现有技术支持和项目分级的考虑，以指导智慧校园的建设。 最后，智慧校园建设的成功依赖于开放、协同和融合的组织建设。通过战略咨询、分步实施、生态建设和短板补充，可以构建符合学校特色的生态链，实现智慧校园的长远发展。
2024-2025学年第一学期2024级新生选课及相关事项的通知.zip
08-29
2024-2025学年第一学期2024级新生选课及相关事项的通知.zip
全球与中国磁性电流传感器芯片市场现状及未来发展趋势（2024版）.docx
08-29
全球与中国磁性电流传感器芯片市场现状及未来发展趋势（2024版）.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值