C++校招八股

已于 2024-05-05 16:26:43 修改
阅读量418 收藏 9
点赞数 3
分类专栏： 嵌入式八股 C++ 文章标签： c++ java 开发语言
于 2024-05-03 14:29:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46150894/article/details/138414214
版权

c++类的访问权限与继承方式

  1. 公有成员在任何地方都可以被访问，包括类的外部和派生类。
  2. 受保护成员在类的内部和派生类中可以被访问，但在类的外部不可访问。

  3. 私有成员只能在类的内部访问，包括类的成员函数和友元函数，不允许在类的外部或派生类中访问。

#include <iostream>
#include <string>
using namespace std;
class Parent
{
    // 公有成员在任何地方都可以被访问，包括类的外部和派生类。
public:
    string name;
    void info_init(string name,string car,int password){
        this->name=name;
        this->car=car;
        this->password=password;
    }
    void print_info(){
        cout<<"name:"<<name<<endl;
        cout<<"car:"<<car<<endl;
        cout<<"password:"<<password<<endl;
    }
    // 受保护成员在类的内部和派生类中可以被访问，但在类的外部不可访问。
protected:
    string car;
    // 私有成员只能在类的内部访问，包括类的成员函数和友元函数，不允许在类的外部或派生类中访问。
private:
    int password;
};

int main()
{
    Parent p1;
    p1.info_init("jay","NIO",10086);
    p1.print_info();
    return 0;
}

多态的构成条件

1.必须通过基类的指针或者引用调用虚函数

2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。重写的三同（函数名，参数，返回值）

3.派生类可不加virtual

#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
    virtual void buy_ticket()
    {
        cout << "成人--全价票" << endl;
    }
};

class Child : public Parent
{
public:
    void buy_ticket()
    {
        cout << "儿童--半价票" << endl;
    }
};

void func(Parent &p)
{
    p.buy_ticket();
}
int main()
{
    Parent p;
    Child c;
    func(p);
    func(c);
    return 0;
}

virtual修饰析构函数

虚析构函数可以确保首先调用子类的析构函数, 然后调用父类的析构函数 ;这样可以避免在释放子类对象时出现资源泄漏的情况 ;
当使用父类指针指向一个子类对象时,如果要通过 delete 释放该指针指向的对象,如果是正常的析构函数, 没有使用 virtual 定义虚析构函数 , 则只会调用父类的析构函数, 子类的析构函数不会被调用到 ;

#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
    Parent()
    {
        cout << "Parent()" << endl;
    }
    virtual ~Parent()
    {
        cout << "~Parent()" << endl;
    }
};

class Child : public Parent
{
public:
    Child()
    {
        cout << "Child()" << endl;
    }
    ~Child()
    {
        cout << "~Child()" << endl;
    }
};

void func(Parent *p)
{
    delete p;
}
int main()
{
    // Parent* p1 = new Parent();
    Child *p2 = new Child();
    func(p2);
    return 0;
}

c++11的override 和 final

  • fianl：修饰虚函数，表示该虚函数不能再被重写
  • 放在类的后面表示该类无法被继承，也就是阻止了从类的继承，放在虚函数后面该虚函数无法被重写，表示阻止虚函数的重载

  • override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

初始化列表 

 初始化列表是一种在构造函数中初始化类成员变量的语法。初始化列表在构造函数体执行之前完成成员的初始化。这种方式有时候比在构造函数中使用赋值更高效，并且适用于那些成员变量是常量或者是引用的情况。

初始化列表用法

const成员变量、引用成员变量、没有默认构造函数的自定义类型成员只能在初始化列表初始化

#include <iostream>
#include <string>
using namespace std;
class Parent
{
public:
    string name;
    // 使用初始化列表可以确保所有成员变量在构造函数体执行前都已初始化
    //初始化列表能只能初始化一次，多次初始化会报错：
    Parent(string name =NULL, int wealth = -1, int password = -1) : name(name), wealth(wealth), password(password)
    {
        cout << "Name: " << name << '\t' << "wealth: " << wealth << '\t' << "password: " << password << endl;
    }

protected:
    int wealth;

private:
    int password;
};

int main()
{
    Parent p("jay", 10000, 10086);
    Parent p1("jj");
    return 0;
}

友元三种实现方式

友元（friend）是一种机制，允许一个类或者函数访问另一个类的私有成员。通过将其他类或函数声明为友元，可以使它们在访问另一个类的私有成员时绕过访问限制。

  1. 全局函数做友元
  2. 类做友元
  3. 成员函数做友元
#include <iostream>
#include <string>
using namespace std;
class Parent
{
    friend void globalFunc(Parent *p);//告诉编译器此函数为友元，可以访问类内私有成员

public:
    string name="jay";

protected:
    int wealth = 8848;

private:
    int password = 10086;
};
//全局函数做友元
void globalFunc(Parent *p)
{
    cout << p->name << endl;
    cout << p->wealth << endl;
    cout << p->password << endl;
}
int main()
{
    Parent p;
    globalFunc(&p);
    return 0;
}
#include <iostream>
#include <string>
using namespace std;
class Parent
{
    friend class GrandParent;//告诉编译器此函数为友元，可以访问类内私有成员

public:
    string name="jay";

protected:
    int wealth = 8848;

private:
    int password = 10086;
};
class GrandParent{
public:
    void getInfo(Parent *p);
};
//全局函数做友元
void GrandParent::getInfo(Parent *p)
{
    cout << p->name << endl;
    cout << p->wealth << endl;
    cout << p->password << endl;
}
int main()
{
    Parent p;
    GrandParent g;
    g.getInfo(&p);
    return 0;
}
#include <iostream>
#include <string>
using namespace std;
class GrandParent
{
public:
    void getInfo();
    void getInfo1();
};

class Parent
{

    friend void GrandParent::getInfo(); // 告诉编译器此函数为友元，可以访问类内私有成员

public:
    string name = "jay";

protected:
    int wealth = 8848;

private:
    int password = 10086;
};

void GrandParent::getInfo()
{
    Parent*p=new Parent;
    cout << "getInfo(): " << p->name << "  " << p->wealth << "  " << p->password << endl;
}
void GrandParent::getInfo1()
{
    Parent*p=new Parent;

    // 无法访问
    //cout << "getInfo1(): " << p->name << "  " << p->wealth << "  " << p->password << endl;
}
int main()
{
    GrandParent g;
    g.getInfo();
    return 0;
}

C++几种构造函数

  1. 默认构造
  2. 有参构造
  3. 拷贝构造
  4. 移动构造函数：接受同一类的对象的右值引用作为参数，用于将资源从一个对象转移到另一个对象，通常用于提高效率。
#include <iostream>
#include <string>
using namespace std;
class MyClass
{
public:
    string data;
    // 默认构造函数：无参数的构造函数，如果类没有定义任何构造函数，则编译器会自动生成默认构造函数。
    // 默认构造函数被用于创建对象时，如果没有提供参数，会被调用。
    MyClass()
    {
        this->data = "默认构造函数";
        cout << "默认构造函数" << endl;
    }
    // 参数化构造函数：带有参数的构造函数，用于接受特定参数来初始化对象的成员变量。
    MyClass(string str) : data(str)
    {
        cout << "有参数构造函数" << endl;
    }
    // 拷贝构造函数：接受同一类的对象作为参数，用于以同一类对象的内容创建新对象。通常用于对象的深拷贝。
    MyClass(const MyClass &obj) : data(obj.data)
    {
        cout << "拷贝构造函数" << endl;
    }
    ~MyClass(){
        cout<<"-----------------------"<<endl;
    }
};

int main()
{
    MyClass obj;
    MyClass obj1("hello");
    MyClass obj2(obj1);
    return 0;
}

 指针和引用

  • 指针是一个变量，其值为另一个变量的地址；引用是一个别名，它相当于已经存在变量的另一个名字。
  • 使用指针可以直接访问或修改内存中的数据。
  • 指针可以被重新赋值指向不同的地址，甚至可以指向空值（nullptr）；引用必须在定义时初始化，并且一旦初始化后不能再引用其他变量
  • 指针需要解引用操作符 * ；引用可以直接访问原始变量的值，而不需要解引用操作符
  • 指针本身占用内存空间；而引用不占用额外的内存空
#include <iostream>
#include <string>
using namespace std;

int main()
{
    int x = 10;
    int *p = &x;  // 指针是一个变量，其值为另一个变量的地址
    int &ref = x; // 引用是一个别名，它相当于已经存在变量的另一个名字;引用必须在定义时初始化，并且一旦初始化后不能再引用其他变量
    cout << "x=" << x << " *p=" << *p << " ref=" << ref << " p=" << p << endl;
    x = 20;
    cout << "x=" << x << " *p=" << *p << " ref=" << ref << " p=" << p << endl;
    *p = 30;
    cout << "x=" << x << " *p=" << *p << " ref=" << ref << " p=" << p << endl;
    ref = 40;
    cout << "x=" << x << " *p=" << *p << " ref=" << ref << " p=" << p << endl;

    return 0;
}

new/delete与malloc/free的异同

相同点

  1. 都可用于内存的动态申请和释放

不同点

  1. 前者是C++运算符，后者是C/C++语言标准库函数
  2. new自动计算要分配的空间大小，malloc需要手工计算
  3. new是类型安全的，返回完整的类型；malloc不是。
  4. new调用名为operator new的标准库函数分配足够空间并调用相关对象的构造函数，delete对指针所指对象运行适当的析构函数；然后通过调用名为operator delete的标准库函数释放该对象所用内存。后者均没有相关调用
  5. 后者需要库文件支持，前者不用；new是封装了malloc,直接free不会报错，但是这只是释放内存，而不会析构对象

解释每个示例的含义

//声明了一个数组 p，数组中包含 10 个指向 int 类型的指针
int *p[10];
//一个指针 p，它指向一个包含 10 个 int 类型元素的数组。
int (*p)[10];
//声明了一个函数 p，该函数接受一个 int 类型的参数，并返回一个 int 类型的指针。
int *p(int);
//声明了一个指针 p，它指向一个函数，该函数接受一个 int 类型的参数，并返回一个 int 类型的值
int (*p)(int);

static在类中的作用

静态成员变量 

  1. static + 类型+变量名后，那么该类 不论 创建了多少个 实例对象 , 这些对象都会共享 该 static " 静态成员变量 " ;
  2. 成员变量一旦加了static关键字后就会处在静态区的，类是处在栈区的， 所以静态的成员变量只能在类外去定义，类内只能是声明，而且不可赋值！！！
  3. 静态成员变量 的 生命周期 就是 程序的声明周期 ;静态成员变量在 应用启动时 初始化 , 在 进程结束时销毁 ;

静态成员变函数 

  1. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  2. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
    Person()
    {
        this->var++;
        this->s_var++;
        cout << "Person(): var=" << this->var <<" s_var="<<this->s_var<<" constVar=" <<this->constVar<<endl;
    }
    ~Person()
    {
        this->var--;
        this->s_var--;
        cout << "~Person(): var=" << this->var <<" s_var="<<this->s_var<<" constVar=" <<this->constVar<<endl;
    }
    static int s_var; // 必须在类内定义，类外初始化,static int s_var=0会报错
    int var=0;//非静态变量可以类内声明并定义.但是不可外部定义
    const int constVar=0;
    static void staticFinc()
    {
        cout << s_var << endl;//静态成员函数没有隐藏的this指针，不能访问任何非静态成员
        //cout << var << endl;
    }
    
};
int Person::s_var = 0; // 在类外部初始化静态成员变量
//int Person::var = 0; // 不可在类外部初始化非静态成员变量
//int Person::constVar=100;
int main()
{
    Person p;
    Person p1;
    return 0;
}

C++ class与struct区别

相同点

  1. 两者都拥有成员函数、公有和私有部分
  2. 任何可以使用class完成的工作，同样可以使用struct完成

不同点

  1. 两者中如果不对成员不指定公私有，struct默认是公有的，class则默认是私有的
  2. class默认是private继承，而struct默认是public继承
#include <iostream>
#include <string>
using namespace std;
struct Person
{
    Person()
    {
        this->name="NULL";
        this->age=-1;
        this->password=-1;
        cout << "Person()" << endl;
    }
    ~Person(){
        cout << "~Person()" << endl;

    }
    void print_info(){
        cout<<"name:"<<name<<" age:"<<age<<" password:"<<password<<endl;
    }
    string name;

protected:
    int age;

private:
    int password;
};
struct Student:Person {
    Student()
    {
        cout << "Student()" << endl;
    }
    ~Student(){
        cout << "~Student()" << endl;

    }

};
int main()
{
    Person p;
    Student s;
    p.name="person";//struct默认是public继承，因此可以访问公有成员
    s.name="student";
    p.print_info();
    s.print_info();
    return 0;
}

C++的顶层const和底层const

概念区分

  • 顶层const:指的是const修饰的变量本身是一个常量，无法修改，指的是指针，就是*号的右边
  • 底层const:指的是const修饰的变量所指向的对象是一个常量，指的是所指变量，就是*号的左边 
int a = 10;int* const b1 = &a;        //顶层const，b1本身是一个常量
const int* b2 = &a;       //底层const，b2本身可变，所指的对象是常量
const int b3 = 20; 		   //顶层const，b3是常量不可变
const int* const b4 = &a;  //前一个const为底层，后一个为顶层，b4不可变
const int& b5 = a;		   //用于声明引用变量，都是底层const

拷贝初始化和直接初始化

在 C++ 中，初始化对象的方式可以分为两种：拷贝初始化（copy initialization）和直接初始化（direct initialization）。

1. 拷贝初始化（Copy Initialization）：

  •    使用等号=进行初始化的方式称为拷贝初始化。
  • 在拷贝初始化中，编译器会尝试使用构造函数将右侧的值转换为左侧的类型，并将结果拷贝到左侧的对象中。这种初始化方式适用于将一个对象的值拷贝给另一个对象，或者通过一个值来初始化一个新的对象。

2. 直接初始化（Direct Initialization）：

  • 在初始化过程中直接使用圆括号（）进行初始化的方式称为直接初始化。
  • 在直接初始化中，编译器会选择合适的构造函数来初始化对象，而不需要进行额外的拷贝操作。

静态类型，动态类型；静态绑定，动态绑定

对C++中的静态类型，动态类型，静态绑定，动态绑定的理解_静态类型和动态类型,静态绑定和动态绑定-CSDN博客

  1. 静态类型：变量声明时候的类型,在编译阶段就可以确定了；
  2. 动态类型：指针或者引用所代表的内存中的对象的类型，在运行阶段才可以确定；
  3. 静态绑定：有人也叫为早绑定，早绑定什么呢？对象所调用的函数的地址，这个阶段是程序编译阶段就确定的了；
  4. 动态绑定：有人也叫晚绑定，也就是编译阶段时候不能确定对象调用函数的地址，需要程序运行到调用函数的阶段才可以确定；

智能指针的原理、常用的智能指针及实现

原理

  • C++ 智能指针底层是采用引用计数的方式实现的。简单的理解，智能指针在申请堆内存空间的同时，会为其配备一个整形值（初始值为 1），每当有新对象使用此堆内存时，该整形值 +1；反之，每当使用此堆内存的对象被释放时，该整形值减 1。当堆空间对应的整形值为 0 时，即表明不再有对象使用它，该堆空间就会被释放掉。

常用的智能指针
(1)shared_ptr
实现原理：采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数会减1，当计数为0的时候会自动的释放动态分配的资源。
 

template<typename T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = NULL):_ptr(ptr), _pcount(new int(1))
	{}

	SharedPtr(const SharedPtr& s):_ptr(s._ptr), _pcount(s._pcount){
		(*_pcount)++;
	}

	SharedPtr<T>& operator=(const SharedPtr& s){
		if (this != &s)
		{
			if (--(*(this->_pcount)) == 0)
			{
				delete this->_ptr;
				delete this->_pcount;
			}
			_ptr = s._ptr;
			_pcount = s._pcount;
			(*_pcount)++;
		}
		return *this;
	}
	T& operator*()
	{
		return *(this->_ptr);
	}
	T* operator->()
	{
		return this->_ptr;
	}
	~SharedPtr()
	{
		--(*(this->_pcount));
		if (*(this->_pcount) == 0)
		{
			delete _ptr;
			_ptr = NULL;
			delete _pcount;
			_pcount = NULL;
		}
	}
private:
	T* _ptr;
	int* _pcount;//指向引用计数的指针
};

运算符重载

成员函数重载

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	int _age=10;
	int _money=10;
	//成员函数重载
	Person operator+(Person&p){
		Person tmp;
		tmp._age=this->_age+p._age;
		tmp._money=this->_money+p._money;
		return tmp;
	}
};

int main()
{
	Person p1,p2,p3;
	p3=p1+p2;//成员函数重载本质 p3=p1.operator+(p2)
	cout<<p3._age<<" "<<p3._money<<endl;//20 20
	return 0;
}

全局函数重载

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	int _age = 10;
	int _money = 10;
};

// 全局函数重载
Person operator+(Person &p1, Person &p2)
{
	Person tmp;
	tmp._age = p1._age + p2._age;
	tmp._money = p1._money + p2._money;
	return tmp;
}
int main()
{
	Person p1, p2, p3;
	p3 = p1 + p2;								 // 全局函数重载本质 p3=operator+(p1,p2)
	cout << p3._age << " " << p3._money << endl; // 20 20
	return 0;
}

Jay-juice
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++后端开发（校招实习生）学习路线
ericma12的博客
04-12 5763
对于没项目的、想找后端实习的在校生，可借鉴此文完善自己的技术路线。
c++面试宝典，常用八股文问题
10-23
c++面试宝典，常用八股文问题 从给定的文件信息中，我们可以提取出以下知识点： 一、学习说明 * 本题库来自海量真实校招面试题目大数据进行的整理，后续也会不断更新。 * 面试题库可以作为帮助同学准备面试的辅助...
校招八股：C/C++开发工程师常见笔试、面试题目不完全汇总【很基础】
baidu_38797690的博客
12-23 4702
一些基础的c/c++面试题，之前面试的时候被问到过，特此记录
C++面试篇之八股文系列
ajbulabula的博客
03-26 2285
与传统的互斥锁（如std::mutex）不同，std::shared_mutex允许多个线程以只读模式共享对资源的访问，但写入操作必须独占资源，防止同时有其他线程对共享资源进行读取或写入。信号量与互斥量的主要区别在于，互斥量允许多个线程对资源的串行访问，而信号量可以控制并发访问资源的线程数量上限。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。
2024年秋招热门面试八股文（C++)
weixin_44747201的博客
08-29 3941
2023年春招热门面试题
开发了一个校招八股文小程序
帅地
10-09 1619
一个帮你拿offer的刷题神器
C/C++入门秋招知识点八股文
拉依达不拉跨的博客
06-20 3839
c、cpp秋招知识点八股文
C++（QT）方向八股文
weixin_43449327的博客
04-09 1689
槽是在响应特定信号时会被调用的方法，Qt的控件存在很多预定义的槽，但通常的做法是继承控件以生成自己的子类，然后添加自己的槽，这样我们就可以自行处理感兴趣的信号。在同一个线程中，当一个信号被emit发出时，会立即执行其槽函数，等槽函数执行完毕后，才会执行emit后面的代码，如果一个信号链接了多个槽，那么会等所有的槽函数执行完毕后才执行后面的代码，槽函数的执行顺序是按照它们链接时的顺序执行的。多态：多态性可以简单的概括为一个接口，多个方法，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。
2024最新大厂C++校招面试真题合集，大厂面试百日冲刺 day17
C/C++Linux、音视频、DPDK
06-20 724
右值引用(R-value References)右值引用是C++11引入的特性之一，用于引用临时对象（右值）。右值引用使用&&来声明。与左值引用相比，它的主要目的是支持转移语义和完美转发。转移语义是指资源（如动态分配的内存）的所有权可以从一个对象转移到另一个对象，这样可以避免不必要的资源复制，提高程序的效率。例如，标准库中的std::move函数就是基于右值引用实现的。// 使用std::move将str1转换为右值引用在上面的例子中，str1的内容被“移动”到str2。
校招C++学习路线
m0_56052659的博客
01-14 1018
校招C++学习路线
C++秋招经验贴
Linke66的博客
11-02 5062
秋招经验贴
C++八股文整理（面试必备）
05-13
### C++ 八股文知识点解析 #### 一、C++语言基础篇 - **智能指针** - **背景与重要性**： - 在C++编程中，内存管理一直是一个挑战。智能指针是一种自动管理动态分配的内存的技术，它们通过在对象生命周期结束时...
cpp八股文+校招+实习+春招+秋招+大厂面试
03-06
cpp八股文，包括但不限于 1 const的用法 2 构造函数的explict关键字 3 inline的内涵 4 friend的用法 5 类型转换4种函数 6 右值的内涵 7 初始化列表作为构造函数的参数 8 多态的原理 9 虚继承的问题 10 delete this...
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1350
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
C++红黑树的底层原理及其实现原理和实现
2302_80214413的博客
09-02 889
今天给大家带来的是红黑树的底层逻辑和底层实现原理及其实现过程，相信大家看完一定会收获满满！~~~
C/C++ 获取 linux 的所有 USB声卡ID及其信息
lijian2017的博客
09-04 1052
popen()在 Linux 下，要获取 USB 声卡的 ID 和名称信息，通常你需要结合多个系统命令和接口，因为 C/C++ 标准库本身并不直接提供这样的功能。下面我将给出一个大致的方向，展示如何通过执行系统命令或使用 Linux 特有的库来实现这一目标。
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 431
Linux 内核编程 /proc 例子代码
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
最新发布
填坑之路
09-06 397
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
C++友类匿名对象，运算符重载
m0_75109289的博客
09-02 256
【代码】C++友类匿名对象，运算符重载。
量化开发 c++ 校招
01-22
量化开发是指利用算法、数学模型和统计方法，以及计算机编程等技术，对金融市场进行量化分析和交易策略的开发与实施。量化开发在金融行业中发挥着重要的作用，也成为了近年来热门的职业方向之一。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jay-juice

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值