首页 > 编程语言 >菜鸟程序员：常用编程知识

菜鸟程序员：常用编程知识

时间：2024-08-12 21:55:07浏览次数：9  
标签：cur parent 程序员 cjson 菜鸟 编程 cJSON root 节点

文章目录

1.有关Linux指令

2.C++容器

类型描述特点
1. vector动态数组，可以通过下表访问，可以快速访问，可以尾部插入删除支持动态大小调整，适用于需要随机访问 和动态增删元素的场景
list双向链表，支持快速插入/删除能够快速插入/删除，但是不支持随机访问元素
map键值对集合，基于红黑树的实现存储键值对，按键自动排序，不允许重复键

2.1 vector

动态数组：

​ 动态增加或减少，不用手动管理内存

#include <iostream>
#include <vector>
int main() {
// 创建一个空的 vector 容器
std::vector<int> myVector;
  
// 向 vector 容器尾部添加元素
myVector.push_back(3);
myVector.push_back(7);
myVector.push_back(12);
  
// 使用迭代器遍历 vector 容器并输出其中的元素
std::cout << "Vector elements: ";
for (auto it = myVector.begin(); it != myVector.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
  
// 获取 vector 容器的大小和访问特定位置的元素
std::cout << "Vector size: " << myVector.size() << std::endl;
std::cout << "Element at index 1: " << myVector[1] << std::endl;
  
// 修改特定位置的元素
myVector[2] = 20;
  
// 使用范围-based for 循环遍历 vector 并输出元素
std::cout << "Modified Vector elements: ";
for (int num : myVector) {
std::cout << num << " ";
}
std::cout << std::endl;
  
// 清空 vector 容器
myVector.clear();
  
// 检查 vector 是否为空
if (myVector.empty()) {
std::cout << "Vector is empty." << std::endl;
} else {
std::cout << "Vector is not empty." << std::endl;
}
return 0;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.2 list

双向链表：

​ 指向下一个节点和上一个节点。

#include <iostream>
#include <list>
int main() {
// 创建一个存储整数的 list 容器
std::list<int> myList;
  
// 在 list 尾部插入元素
myList.push_back(10);
myList.push_back(20);
myList.push_back(30);
  
// 在 list 头部插入元素
myList.push_front(5);
myList.push_front(15);
  
// 使用迭代器遍历 list 并输出元素
std::cout << "List elements: ";
for (auto it = myList.begin(); it != myList.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
  
// 删除 list 中特定的元素值
myList.remove(20);
  
// 使用范围-based for 循环遍历 list 并输出元素
std::cout << "List elements after removal: ";
for (int num : myList) {
std::cout << num << " ";
}
std::cout << std::endl;
  
// 检查 list 是否为空
if (myList.empty()) {
std::cout << "List is empty." << std::endl;
} else {
std::cout << "List is not empty." << std::endl;
}
return 0;
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.3 map

自平衡红黑树：

​ 用于储存键值对。

insert() : 向 map 中插入一个键值对。
erase() : 删除 map 中指定键的键值对。
find() : 查找指定键在 map 中的位置。
operator[] : 通过键访问对应的值。
size() : 返回 map 中键值对的数量。
empty() : 检查 map 是否为空。
clear() : 清空 map 中的所有键值对。

#include <iostream>
#include <map>
int main() {
// 创建一个存储 string 类型键和 int 类型值的 map 容器
std::map<std::string, int> myMap;
  
// 向 map 中插入键值对
myMap["Alice"] = 25;
myMap["Bob"] = 30;
myMap["Charlie"] = 20;
  
// 使用迭代器遍历 map 并输出键值对
std::cout << "Map elements: " << std::endl;
for (auto it = myMap.begin(); it != myMap.end(); ++it) {
std::cout << it->first << ": " << it->second << std::endl;
}
  
// 查找特定键在 map 中的位置
std::string searchKey = "Bob";
auto found = myMap.find(searchKey);
if (found != myMap.end()) {
std::cout << "Found " << searchKey << " with value: " << found->second <<
std::endl;
} else {
std::cout << searchKey << " not found in the map." << std::endl;
}
  
// 删除特定键的键值对
myMap.erase("Charlie");
  
// 检查 map 是否为空
if (myMap.empty()) {
std::cout << "Map is empty." << std::endl;
} else {
std::cout << "Map is not empty." << std::endl;
}
return 0;
}

3.红黑树

3.1 节点定义

enum Color{RED, BLACK};//节点颜色
 
//约定value唯一
template<class T>
struct RBTreeNode {//节点定义
	RBTreeNode(const T& value = T(), Color color = RED)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _value(value)
		, _color(color)
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _value;
	Color _color;
};
//节点一般为红色

3.2 结构

	为了方便现关联式容器，在红黑树的实现中加入一个头结点。因为根节点必须是黑色，为了与根节点进行区分，将头节点给定为红色。让根节点的_parent指针域指向头节点，并且让头结点的_parent指针域指向红黑树根节点；_left指针域指向红黑树中最左侧节点，_right指针域指向红黑树中最右侧节点。

在这里插入图片描述

3.3 性质

​ 红黑树保证最长路径不超过最短路径的二倍，因而近似平衡（最短路径就是全黑节点，最长路径就是一个红节点一个黑节点，当从根节点到叶子节点的路径上黑色节点相同时，最长路径刚好是最短路径的两倍）

1、节点是红色或黑色
2、根是黑色
3、叶子节点（外部节点，空节点）都是黑色，这里的叶子节点指的是最底层的空节点（外部节点），下图中的那些null节点才是叶子节点，null节点的父节点在红黑树里不将其看作叶子节点。
4、红色节点的子节点都是黑色
		红色节点的父节点都是黑色
		从根节点到叶子节点的所有路径上不能有 2 个连续的红色节点
5、从任一节点到叶子节点的所有路径都包含相同数目的黑色节点。

在这里插入图片描述

3.4 红黑树实现

enum Color{RED, BLACK};//节点颜色
 
template<class T>
struct RBTreeNode {//节点定义
	RBTreeNode(const T& value = T(), Color color = RED)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _value(value)
		, _color(color)
	{}
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _value;
	Color _color;
};
 
//约定value唯一
template<class T>
class RBTree {
	typedef RBTreeNode<T> Node;
public:
	RBTree() {
		_head = new Node();
		_head->_left = _head;
		_head->_right = _head;
	}
  
	~RBTree() {
		Destroy(_head->_parent);
		delete _head;
		_head = nullptr;
	}
 //
  
	//插入
	bool Insert(const T& value) {
		Node*& root = GetRoot();
		//1.按照二叉搜索树的方式插入
		if (root == nullptr) {//空树
			root = new Node(value, BLACK);
			root->_parent = _head;
			_head->_left = root;
			_head->_right = root;
			return true;
		}
		//查找插入位置
		Node* cur = root;
		Node* parent = cur->_parent;
		while (cur) {
			parent = cur;//保存其双亲
			if (value < cur->_value) {
				cur = cur->_left;
			}
			else if (value > cur->_value) {
				cur = cur->_right;
			}
			else {//已存在
				return false;
			}
		}
		//插入新节点
		cur = new Node(value);//默认插入节点为红色
		if (value < parent->_value) {
			parent->_left = cur;
		}
		else {
			parent->_right = cur;
		}
		cur->_parent = parent;
      
		//2.红黑树性质约束
		while (parent != _head && parent->_color == RED) {//两个红色相连违法规则
			Node* grandFather = parent->_parent;
			if (parent == grandFather->_left) {
				Node* uncle = grandFather->_right;
				//情况一：叔叔节点存在且为红
				if (uncle && uncle->_color == RED) {
					parent->_color = BLACK;
					uncle->_color = BLACK;
					grandFather->_color = RED;
					//改变cur，继续向上调整
					cur = grandFather;
					parent = cur->_parent;
				}
				else {//情况二或三：叔叔节点为空，或叔叔节点存在且为黑
					//因为情况三可以调整为情况二，所有先处理情况三
					if (cur == parent->_right) {
						//将情况三转换为情况二
						RotateLeft(parent);
						std::swap(parent, cur);
					}
					//情况二
					parent->_color = BLACK;
					grandFather->_color = RED;
					RotateRight(grandFather);
				}
			}
			else {//三种情况的对称情况-->解决方法相同
				Node* uncle = grandFather->_left;
				if (uncle && uncle->_color == RED) {//情况一
					parent->_color = BLACK;
					uncle->_color = BLACK;
					grandFather->_color = RED;
					//改变cur，继续向上调整
					cur = grandFather;
					parent = cur->_parent;
				}
				else {//情况二或三
					if (cur == parent->_left) {//情况三
						//调整为情况二
						RotateRight(parent);
						std::swap(cur, parent);
					}
					//情况二
					parent->_color = BLACK;
					grandFather->_color = RED;
					RotateLeft(grandFather);
				}
 
			}
		}
		//最后根节点可能被调整为了红色，所以需要被改回黑色
		root->_color = BLACK;
 
		//3.更新头结点左右指针域--插入元素可能改变树的最值
		_head->_left = MostLeft();
		_head->_right = MostRight();
		return true;
	}
 /
	//查找
	Node* Find(const T& value) {
		Node*& root = GetRoot();
		if (root == nullptr) return nullptr;
		Node* cur = root;
		while (cur) {
			if (value < cur->_value) {
				cur = cur->_left;
			}
			else if (value > cur->_value) {
				cur = cur->_right;
			}
			else {
				return cur;
			}
		}
		return nullptr;
	}
 
	//检测是否是红黑树
	bool IsRBTree() {
		Node* root = GetRoot();
		if (root == nullptr) return true;
		if (root->_color == RED) {
			//检测性质2
			std::cout << "FALSE: 根节点为红色！" << std::endl;
			return false;
		}
		int blackCount = 0;
		Node* cur = root;
		while (cur) {//统计一条路径黑色节点个数
			if (cur->_color == BLACK) ++blackCount;
			cur = cur->_left;
		}
		return _IsRBTree(root, blackCount, 0);
	}
 
	//中序遍历
	void InOrder() {
		_InOrder(GetRoot());
		std::cout << std::endl;
	}
	//获取最值
	int GetMax() {
		return MostRight()->_value;
	}
	int GetMin() {
		return MostLeft()->_value;
	}
 
private:
	//获取根节点
	Node*& GetRoot() {
		return _head->_parent;
	}
	//获取树的最值节点
	Node* MostLeft() {//最左侧节点
		Node*& root = GetRoot();
		if (root == nullptr) return _head;
		Node* cur = root;
		while (cur->_left) {
			cur = cur->_left;
		}
		return cur;
	}
	Node* MostRight() {//最右侧节点
		Node*& root = GetRoot();
		if (root == nullptr) return _head;
		Node* cur = root;
		while (cur->_right) {
			cur = cur->_right;
		}
		return cur;
	}
	//左单旋
	void RotateLeft(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL) {//注意subrl可能为空
			subRL->_parent = parent;
		}
		subR->_left = parent;
		//跟新parent和subR的双亲节点
		//先保存好parent原先的双亲节点
		Node* pparent = parent->_parent;
		parent->_parent = subR;
		subR->_parent = pparent;
		//处理上层节点
		if (pparent == _head) {//已经更新到根节点
			_head->_parent = subR;
		}
		else {
			if (parent == pparent->_left) {
				pparent->_left = subR;
			}
			else {
				pparent->_right = subR;
			}
		}
	}
	//右单旋
	void RotateRight(Node* parent) {
		//其思想与左单旋相同
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		subL->_right = parent;
		Node* pparent = parent->_parent;
		parent->_parent = subL;
		subL->_parent = pparent;
		if (pparent == _head) {
			_head->_parent = subL;
		}
		else {
			if (parent == pparent->_left) {
				pparent->_left = subL;
			}
			else {
				pparent->_right = subL;
			}
		}
	}
	//检测是否满足红黑树特性
	bool _IsRBTree(Node* root, const int blackNum, int count) {
		if (root == nullptr) return true;
		if (root->_color == BLACK) ++count;//统计路径内的黑色节点
		//检测是否满足性质3
		if (root->_parent != _head && root->_color == RED && root->_parent->_color == RED) {
			std::cout << "FALSE: 存在两个相连的红色节点！" << std::endl;
			return false;
		}
		if (root->_left == nullptr && root->_right == nullptr) {
			//是叶子节点，此路径统计结束
			return count == blackNum;//检测性质4
		}
		return _IsRBTree(root->_left, blackNum, count) && _IsRBTree(root->_right, blackNum, count);
	}
	//中序遍历
	void _InOrder(Node*& root) {
		if (root == nullptr) return;
		_InOrder(root->_left);
		std::cout << root->_value << " ";
		_InOrder(root->_right);
	}
	//销毁
	void Destroy(Node* root) {
		if (root == nullptr) return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}
private:
	Node* _head;
};

4.libev库定时器

4.1 定时器的初始化

//定时器初始化
struct ev_loop *loop = EV_DEFAULT;//通过 EV_DEFAULT 宏，获取到默认的事件循环。

ev_timer timer;
ev_timer_init(&timer, timerCallback, 0.0, 2.0); // 2秒定时器
timer.data = this->Mcfcb; // timer这个结构体中date的初始化

ev_timer_start(loop, &timer);//将定时器 timer 添加到事件循环 loop 中，并开始计时。如果定时器的延迟时间已过（在这个例子中是 0.0），它会立即触发；否则，它会在指定的延迟时间后触发。
ev_run(loop, 0);//启动事件循环。ev_run 函数会阻塞调用线程，直到没有更多活动的事件监听器或调用了 ev_break 函数。参数 0 表示使用默认的行为（即无限循环，直到没有更多事件或调用了 ev_break）。

ev_run(loop, int flags);
/*
libev 中常见的 flags 参数包括：
0 或 EVRUN_DEFAULT：这是默认值，表示事件循环将无限期地运行，直到没有活动的事件监听器为止。
EVRUN_ONCE：事件循环将只运行一次，处理当前所有待处理的事件，然后退出。
EVRUN_NOWAIT：事件循环将检查是否有待处理的事件，如果有则处理它们，并立即返回，而不会等待新事件的到来。*/

4.2 回调函数

void CUpReportPeriodData::timerCallback(struct ev_loop *loop, ev_timer *w, int revents)
{
	struct C_FCB *self = static_cast<struct C_FCB*>(w->data);
	std::cout<<"ZHW into CB"<<"FCB:"<<self->FCB<<","<<"flag:"<<self->flag<<","<<revFlag<<std::endl;
	//如果FCB不为0，FCB--，再次更新控制域，发送报文
	if (revFlag == 1) {
		std::cout<<"zhw:"<<self->FCB<<std::endl;
		ev_timer_stop(loop, w);
	}
	else if(revFlag==0)
	{
		if(self->FCB > 0)
		{
			self->FCB--;
			std::cout<<"FCB:"<<self->FCB<<std::endl;
		}
		else if(self->FCB==0)
		{
			revFlag=1;
		}
		ev_timer_stop(loop, w);
	}
}

void timerCallback(struct ev_loop *loop, ev_timer *w, int revents);
/*
一般revents这个函数不会被使用
struct ev_loop *loop:
	这是一个指向当前事件循环的指针。libev 允许有多个事件循环实例，但这个函数通常只与触发它的那个事件循环相关。在这个回调函数中，可以使用这个指针来访问和操作该事件循环，比如添加新的watcher、修改定时器等。
ev_timer *w:
	指向触发回调函数的定时器watcher的指针。通过这个指针，可以访问定时器watcher的所有属性，包括与定时器相关联的用户数据（通过 w->data 访问）。
revents：
	一般这个函数不会被使用。
*/

5. CJSON

5.1 JSON数据封装

在这里插入图片描述

#include <stdio.h>
#include "cJSON.h"

int main(void)
{
    cJSON* cjson_test = NULL;
    cJSON* cjson_address = NULL;
    cJSON* cjson_skill = NULL;
    char* str = NULL;

    /* 创建一个JSON数据对象(链表头结点) */
    cjson_test = cJSON_CreateObject();

    /* 添加一条字符串类型的JSON数据(添加一个链表节点) */
    cJSON_AddStringToObject(cjson_test, "name", "mculover666");

    /* 添加一条整数类型的JSON数据(添加一个链表节点) */
    cJSON_AddNumberToObject(cjson_test, "age", 22);

    /* 添加一条浮点类型的JSON数据(添加一个链表节点) */
    cJSON_AddNumberToObject(cjson_test, "weight", 55.5);

    /* 添加一个嵌套的JSON数据（添加一个链表节点） */
    cjson_address = cJSON_CreateObject();
    cJSON_AddStringToObject(cjson_address, "country", "China");
    cJSON_AddNumberToObject(cjson_address, "zip-code", 111111);
    cJSON_AddItemToObject(cjson_test, "address", cjson_address);

    /* 添加一个数组类型的JSON数据(添加一个链表节点) */
    cjson_skill = cJSON_CreateArray();
    cJSON_AddItemToArray(cjson_skill, cJSON_CreateString( "C" ));
    cJSON_AddItemToArray(cjson_skill, cJSON_CreateString( "Java" ));
    cJSON_AddItemToArray(cjson_skill, cJSON_CreateString( "Python" ));
    cJSON_AddItemToObject(cjson_test, "skill", cjson_skill);

    /* 添加一个值为 False 的布尔类型的JSON数据(添加一个链表节点) */
    cJSON_AddFalseToObject(cjson_test, "student");

    /* 打印JSON对象(整条链表)的所有数据 */
    str = cJSON_Print(cjson_test);
    printf("%s\n", str);

    return 0;
}

5.2 JSON数据解析

/*
1.创建链表头指针
*/
cJSON* cjson_test = NULL;

/*
2.数据解析：
	数据解析的API只有1个，返回的是链表头节点的地址
	(cJSON *) cJSON_Parse(const char *value)
*/
cjson_test=(cJSON *) cJSON_Parse(str);

/*
3.根据键值对的名称从链表中去除对应的值，返回的是该键值对的地址
	(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
*/
cJSON* cjson_get=(cJSON *) cJSON_GetObjectItem(cjson_test, "zhw");

/*
4.提取数组的数据：
	(int) cJSON_GetArraySize(const cJSON *array);
	(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
*/


char *message = 
"{                              \
    \"name\":\"mculover666\",   \
    \"age\": 22,                \
    \"weight\": 55.5,           \
    \"address\":                \
        {                       \
            \"country\": \"China\",\
            \"zip-code\": 111111\
        },                      \
    \"skill\": [\"c\", \"Java\", \"Python\"],\
    \"student\": false          \
}";

  cJSON* cjson_test = NULL;
    cJSON* cjson_name = NULL;
    cJSON* cjson_age = NULL;
    cJSON* cjson_weight = NULL;
    cJSON* cjson_address = NULL;
    cJSON* cjson_address_country = NULL;
    cJSON* cjson_address_zipcode = NULL;
    cJSON* cjson_skill = NULL;
    cJSON* cjson_student = NULL;
    int    skill_array_size = 0, i = 0;
    cJSON* cjson_skill_item = NULL;

    /* 解析整段JSO数据 */
    cjson_test = cJSON_Parse(message);
    if(cjson_test == NULL)
    {
        printf("parse fail.\n");
        return -1;
    }

    /* 依次根据名称提取JSON数据（键值对） */
    cjson_name = cJSON_GetObjectItem(cjson_test, "name");
    cjson_age = cJSON_GetObjectItem(cjson_test, "age");
    cjson_weight = cJSON_GetObjectItem(cjson_test, "weight");
    printf("name: %s\n", cjson_name->valuestring);
    printf("age:%d\n", cjson_age->valueint);
    printf("weight:%.1f\n", cjson_weight->valuedouble);

    /* 解析嵌套json数据 */
    cjson_address = cJSON_GetObjectItem(cjson_test, "address");
    cjson_address_country = cJSON_GetObjectItem(cjson_address, "country");
    cjson_address_zipcode = cJSON_GetObjectItem(cjson_address, "zip-code");
    printf("address-country:%s\naddress-zipcode:%d\n", cjson_address_country->valuestring, cjson_address_zipcode->valueint);

    /* 解析数组 */
    cjson_skill = cJSON_GetObjectItem(cjson_test, "skill");
    skill_array_size = cJSON_GetArraySize(cjson_skill);
    printf("skill:[");
    for(i = 0; i < skill_array_size; i++)
    {
        cjson_skill_item = cJSON_GetArrayItem(cjson_skill, i);
        printf("%s,", cjson_skill_item->valuestring);
    }
    printf("\b]\n");

    /* 解析布尔型数据 */
    cjson_student = cJSON_GetObjectItem(cjson_test, "student");
    if(cjson_student->valueint == 0)
    {
        printf("student: false\n");
    }
    else
    {
        printf("student:error\n");
    }
    
    return 0;

在这里插入图片描述

标签：cur,parent,程序员,cjson,菜鸟,编程,cJSON,root,节点
From： https://blog.csdn.net/zhwlit/article/details/141131402

相关文章

  • 【C++面向对象】泛型编程（模板） 新手小白都能懂！
    目录泛型编程是什么？模板和泛型编程的关系？函数模板定义调用类模板定义调用总结/小注泛型编程是什么？顾名思义，“泛型”即“广泛的类型”，即不拘泥于一种特定类型的编程方法。在泛型编程时，我们通常使用一个或多个类型占位符来表示一种或多种类型，这些类型对于模板而言......
  • 网络编程
    网络编程1.计算机网络1.1.什么是计算机网络计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来，实现资源共享和数据传输的系统。1.2.什么是网络编程网络编程就是编写程序使联网的两个(或多个)设备(例如计算机)之间进行数据传输。Java语......
  • GUI编程process4
    1、GUI编程（AWT，Swing）图形界面编程元素：窗口，弹窗，面板，文本框，列表框，按钮，图片，监听时间，鼠标，键盘事件，破解工具2、简介Gui的核心技术：Wing和AWT,因为界面不美观，需要jre环境AWT（AbstractWindowToolkit）是‌Java中最早的图形用户界面开发包，而Swing是在AWT的基础上构建的。Swing组件......
  • 指针4.指针变量(附编程习题)
    今天来归纳一下指针变量,及了解typedef关键字和二维数组传参本质目录1.字符指针变量2.数组指针变量2.1概念2.2数组指针初始化3.函数指针变量4.函数指针数组5.二维数组传参6.typedef练习1.计算器的一般实现代码运行结果2.找单身狗2代码3.获得月份天数代码运行结果......
  • 重头开始嵌入式第十八天（Linux系统编程 文件IO）
    Linux系统编程内容Linux系统编程涵盖了众多方面的知识和技术： 1. 文件I/O操作：包括打开、读取、写入、关闭文件，以及处理文件的权限、属性等。2. 进程管理：创建新进程、进程的终止、等待进程结束、进程的执行状态控制等。3. 信号处理：接收和处理系统发送的各种信号，以响......
  • 网络编程学习总结
    Java网络编程学习总结本章目标了解计算机网络基础知识了解OSI七层参考模型熟悉TCP/IP协议熟悉常见网络协议掌握socket套接字编程计算机网络什么是计算机网络计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来，实现资源共......
  • 掌握JavaScript中的观察者模式：构建响应式编程的基石
    标题：掌握JavaScript中的观察者模式：构建响应式编程的基石在软件开发中，设计模式是解决特定问题的模板。其中，观察者模式是一种非常重要的设计模式，它允许多个对象监听另一个对象的状态变化，并在该对象状态变化时得到通知。这种模式在JavaScript中尤为有用，尤其是在构建响应式应用......
  • 腾讯云AI代码助手 —— 编程新体验，智能编码新纪元
    阅读导航引言一、开发环境介绍1.支持的编程语言2.支持的集成开发环境（IDE）二、腾讯云AI代码助手使用实例1.开发环境配置2.代码补全功能使用......
  • 编程题之Daily Temperatures
    LeetCode原题地址https://leetcode.com/problems/daily-temperatures/题目介绍Givenanarrayofintegerstemperaturesrepresentsthedailytemperatures,returnanarrayanswersuchthatanswer[i]isthenumberofdaysyouhavetowaitaftertheithdaytogeta......
  • 这年头，程序员开始卷AI编程了？
    在AI技术飞速发展的背景下，相信大家都有目共睹，各种AI技术的普及让很多复杂的工作变得简单高效，如大语言模型和AI绘画、AI视频等，但是目前最吸引我的莫过于“AI代码生成”。在过去，每次有新技术出现时，我们都需要花大量时间去学习，比如一门新的语言，即便是资深的程序员至少要了解其......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99