自己写的LinkList

最新推荐文章于 2022-07-29 21:14:49 发布
最新推荐文章于 2022-07-29 21:14:49 发布
阅读量342 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dolphin98629/article/details/53884592 
Source FILE: CAlgCommon.h


#ifndef _C_ALG_COMMON_H_
#define _C_ALG_COMMON_H_
#include <string.h>
#include <stdlib.h>


#ifndef __cplusplus
#define inline __inline
#endif


#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
	CALG_ENUM_NEXT = 0,
	CALG_ENUM_REPEAT ,
	CALG_ENUM_STOP 
}CAlgEnum;


typedef CAlgEnum (*Alg_IteRator_F)(void* elem);
typedef int (*Alg_Cmp_F)(const void* left, const void* right, unsigned int size);


#ifdef __cplusplus
}
#endif


#endif
//end of file


Source File: CAlgList.h

#ifndef _C_ALG_LIST_H_
#define _C_ALG_LIST_H_
#include <string.h>
#include <stdlib.h>
#include "CAlgCommon.h"


#ifdef __cplusplus
extern "C" {
#endif


typedef struct _CAlgNode{
	void * curr_data;
	
	struct _CAlgNode * prev;
	struct _CAlgNode * next;
}CAlgNode;


typedef struct {
	CAlgNode* head;
	CAlgNode* tail;
	int elem_count;
	unsigned int elem_size;
}CAlgList;


static inline void CAlgList_ReSet(CAlgList* l, unsigned int elem_size)
{
	l->head = l->tail = NULL;
	l->elem_count = 0;
	l->elem_size = elem_size;
}


static inline void CAlgList_Insert(CAlgList* l, CAlgNode* prev, CAlgNode* n)
{
	n->prev = prev;	
	if(prev)
	{
		n->next = prev->next;
		prev->next = n;
	}
	else
	{
		n->next = l->head;
		l->head = n;
	}
	if(n->next)
		n->next->prev = n;
	if(prev == l->tail)
		l->tail = n;
	l->elem_count ++;
}


static inline CAlgNode* CAlgList_AddHead(CAlgList* l, CAlgNode* n)
{
	CAlgList_Insert(l, NULL, n);
	return l->head;
}


static inline CAlgNode* CAlgList_AddTail(CAlgList* l, CAlgNode* n)
{
	CAlgList_Insert(l, l->tail, n);
	return l->tail;
}


static inline CAlgNode* CAlgList_Find(CAlgList* l, void* data, Alg_Cmp_F node_cmp)
{
	CAlgNode* tmp = l->head;
	if(node_cmp == NULL)
	node_cmp = memcmp;
	while(tmp)
	{
		if(0 == node_cmp(tmp->curr_data, data, l->elem_size))
			return tmp;
		tmp = tmp->next;
	}
	return NULL;
}


static inline int CAlgList_RemoveNode(CAlgList* l, CAlgNode* n)
{
	if( NULL == n) return -1;
	if(n == l->head)
		l->head = l->head->next;
	if(n == l->tail)
		l->tail = l->tail->prev;
	if(n->prev)
		n->prev->next = n->next;
	if(n->next)
		n->next->prev = n->prev;
	if(n)
		l->elem_count --;
	return 0;
}


static inline CAlgNode* CAlgList_RemoveHead(CAlgList* l)
{
	CAlgNode* head = l->head;
	CAlgList_RemoveNode(l, l->head);
	return head;
}


static inline CAlgNode* CAlgList_RemoveTail(CAlgList* l)
{
	CAlgNode* tail = l->tail;
	CAlgList_RemoveNode(l, l->tail);
	return tail;
}


#define ALGLIST_FOREACH(alglist, node) do{\
node = alglist->head;\
for(; NULL != node; node=node->next){


#define ALGLIST_FOREACH_END() }}while(0);


static inline int CAlgList_Enum(const CAlgList* l, Alg_IteRator_F it, int reverse)
{
	int count = 0u;
	CAlgNode* tmp ;
	CAlgEnum rc ;
	if(reverse)
		tmp = l->tail;
	else
		tmp = l->head;
	while(tmp)
	{
		count ++;
		rc = it(tmp->curr_data);
		if(rc == CALG_ENUM_REPEAT)
			continue;
		else if(rc == CALG_ENUM_STOP)
			return count;
		if(reverse)
			tmp = tmp->prev;
		else
			tmp = tmp->next;
	}
	return count;
}
#ifdef __cplusplus
}
#endif
#endif//end of file
单元测试： 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "CAlgList.h"


typedef struct {
	int a;
	int b;
}CAlgListNodeData;


#define MAX_NODE_ELEM   10000000
static CAlgListNodeData* g_NodeDataPool = NULL;
static CAlgNode* g_CAlgNodes = NULL;
static CAlgList* g_CAlgList = NULL;


extern "C" CAlgEnum TestAlgList_Enum(void* elem)
{
	CAlgListNodeData* e = (CAlgListNodeData*)elem;
	printf("%5d, a=%5d, b=%5d\n", e - g_NodeDataPool, e->a, e->b);
	return CALG_ENUM_NEXT;
}


extern "C" CAlgEnum TestAlgList_EnumNothing(void* elem)
{
	return CALG_ENUM_NEXT;
}


extern "C" static int TestAlgList_node_cmp(const void* left, const void* right, unsigned int size)
{
	CAlgListNodeData* l, *r;
	l = (CAlgListNodeData*)left;
	r = (CAlgListNodeData*)right;
	if (l->a != r->a) 
		return l->a - r->a;

	return l->b - r->b;
}


void TestAlgList_Init()
{
	g_NodeDataPool = (CAlgListNodeData*)malloc(sizeof(CAlgListNodeData)*MAX_NODE_ELEM);
	g_CAlgNodes = (CAlgNode*)malloc(sizeof(CAlgNode)*MAX_NODE_ELEM);
	g_CAlgList = (CAlgList*)malloc(sizeof(CAlgList));


	CAlgList_ReSet(g_CAlgList, sizeof(CAlgListNodeData));
}


void TestAlgList_Free()
{
	free(g_NodeDataPool);
	g_NodeDataPool = NULL;

	free(g_CAlgNodes);
	g_CAlgNodes = NULL;

	free(g_CAlgList);
	g_CAlgList = NULL;
}


void TestAlgList_AddAll_Pointer(int add_tail)
{
	CAlgNode* n = g_CAlgNodes;
	CAlgListNodeData* d = g_NodeDataPool;
	int i;
	for(i=0; i<MAX_NODE_ELEM; i++)
	{
		d->a = i+1;
		d->b = i+2;

		n[i].curr_data = (void*)d;
		if(add_tail)
			CAlgList_AddTail(g_CAlgList, &n[i]);
		else
			CAlgList_AddHead(g_CAlgList, &n[i]);

		d++;
		assert(g_CAlgList->elem_count == i +1);
	}

	i=0;
	n = g_CAlgList->head;
	do{
		if(n == g_CAlgList->head)
		{
			assert(n->prev == NULL);
		}
		if(n == g_CAlgList->tail)
		{
			assert(n->next == NULL);
		}

		d = (CAlgListNodeData*)n->curr_data;
		if(add_tail){
			assert(d->a == i+1);
			assert(d->b == i+2);
		}
		else
		{
			assert(d->a == MAX_NODE_ELEM - i);
			assert(d->b == MAX_NODE_ELEM - i +1);
		}

		i++;
	}while(n=n->next);
	assert(i == MAX_NODE_ELEM);
	assert(g_CAlgList->elem_count == MAX_NODE_ELEM);
}


void TestAlgList_RemoveHead()
{
	CAlgNode* n = g_CAlgNodes;
	CAlgListNodeData* d;
	int i;


	for(i=0; i<MAX_NODE_ELEM; i++)
	{
		n = CAlgList_RemoveHead( g_CAlgList);
		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);
		assert(g_CAlgList->elem_count == MAX_NODE_ELEM - i -1);
	}

	assert(g_CAlgList->head == NULL);
	assert(g_CAlgList->tail == NULL);
}

void TestAlgList_RemoveTail()
{
	CAlgNode* n = g_CAlgNodes;
	CAlgListNodeData* d;
	int i;


	for(i=0; i<MAX_NODE_ELEM; i++)
	{
		n = CAlgList_RemoveTail( g_CAlgList);
		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);
		assert(g_CAlgList->elem_count == MAX_NODE_ELEM - i - 1);
	}

	assert(g_CAlgList->head == NULL);
	assert(g_CAlgList->tail == NULL);
}


void TestAlgList_Insert_Remove()
{
	const int node_num = 10;
	CAlgNode* n = g_CAlgNodes;
	CAlgListNodeData* d = g_NodeDataPool;
	int i;
	CAlgListNodeData tmp;


	//list empty find fail
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[node_num/2+i];
		tmp.a = i+1;
		tmp.b = i+2;

		n = CAlgList_Find(g_CAlgList, &tmp, TestAlgList_node_cmp);
		assert(n == NULL);
	}

	//list empty remove fail
	assert (NULL == CAlgList_RemoveTail( g_CAlgList));
	assert (NULL == CAlgList_RemoveHead( g_CAlgList));
	assert (g_CAlgList->elem_count == 0);

	//add node_num/2 nodes
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[i];
		d->a = i+1;
		d->b = i+2;

		g_CAlgNodes[i].curr_data = (void*)d;
		CAlgList_AddTail( g_CAlgList, &g_CAlgNodes[i]);

		assert(g_CAlgList->elem_count == i +1);
	}

	assert(g_CAlgList->elem_count == node_num/2);
	printf("add 5 nodes using CAlgList_AddTail()\n");
	CAlgList_Enum(g_CAlgList,TestAlgList_Enum,0);

	//insert node_num/2 nodes into the list
	//1,      2,      3,      4,      5 
	//1,1001, 2,1002, 3,1003, 4,1004, 5,1005
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[node_num/2+i];
		tmp.a = i+1;
		tmp.b = i+2;

		n = CAlgList_Find( g_CAlgList, &tmp, TestAlgList_node_cmp);
		assert(n != NULL);

		d->a = 1000+i+1;
		d->b = 2000+i+1;

		g_CAlgNodes[node_num/2+i].curr_data = d;

		CAlgList_Insert(g_CAlgList, n, &g_CAlgNodes[node_num/2+i]);
	}
	printf("\nafter add 5 nodes using CAlgList_Insert()\n");
	CAlgList_Enum(g_CAlgList,TestAlgList_Enum,0);

	i=0;
	n = g_CAlgList->head;
	do{
		if(n == g_CAlgList->head)
		{
			assert(n->prev == NULL);
		}
		if(n == g_CAlgList->tail)
		{
			assert(n->next == NULL);
		}

		d = (CAlgListNodeData*)n->curr_data;
		if((i % 2) == 0)
		{
			assert(d->a == i/2+1);
			assert(d->b == i/2+2);
		}
		else
		{
			assert(d->a == 1000+i/2+1);
			assert(d->b == 2000+i/2+1);
		}

		i++;
	}while(n=n->next);
	assert(i == node_num);
	assert(g_CAlgList->elem_count == node_num);


	//remove node 1001,1002,1003,1004,1005
	//before 1,1001, 2,1002, 3,1003, 4,1004, 5,1005
	//after  1,      2,      3,      4,      5 
	for(i=0; i<node_num/2; i++)
	{
		tmp.a = 1000+i+1;
		tmp.b = 2000+i+1;
		n = CAlgList_Find( g_CAlgList, &tmp, TestAlgList_node_cmp);
		assert(n != NULL);
		assert(0 == CAlgList_RemoveNode( g_CAlgList, n));
	}
	printf("\nafter remove 5 nodes using CAlgList_RemoveNode\n");
	CAlgList_Enum(g_CAlgList,TestAlgList_Enum,0);
	assert(g_CAlgList->elem_count == node_num/2);

	i=0;
	n = g_CAlgList->head;
	do{
		if(n == g_CAlgList->head)
		{
			assert(n->prev == NULL);
		}
		if(n == g_CAlgList->tail)
		{
			assert(n->next == NULL);
		}

		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);

		i++;
	}while(n=n->next);

	//remove head 1
	//after  2,      3,      4,      5 
	n = CAlgList_RemoveHead( g_CAlgList);
	assert(n != NULL && g_CAlgList->elem_count > 2);
	d = (CAlgListNodeData*)n->curr_data;
	assert(d->a == 1);
	assert(d->b == 2);


	//remove tail 5
	//after  2,      3,      4,      
	n = CAlgList_RemoveTail( g_CAlgList);
	assert(n != NULL && g_CAlgList->elem_count > 2);
	d = (CAlgListNodeData*)n->curr_data;
	assert(d->a == 5);
	assert(d->b == 6);

	assert(g_CAlgList->elem_count == 3);
	i=1;
	n = g_CAlgList->head;
	do{
		if(n == g_CAlgList->head)
		{
			assert(n->prev == NULL);
		}
		if(n == g_CAlgList->tail)
		{
			assert(n->next == NULL);
		}

		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);

		i++;
	}while(n=n->next);
	assert(i == 4);
	printf("\nafter CAlgList_RemoveHead && CAlgList_RemoveTail\n");
	CAlgList_Enum(g_CAlgList,TestAlgList_Enum,0);

	//remove all
	while(CAlgList_RemoveHead( g_CAlgList))
		printf("remove...\n");

	assert(g_CAlgList->elem_count == 0);
}




#include <Windows.h>
void TestAlgList_Run()
{
	SYSTEMTIME st1, st2;
	FILETIME ft1, ft2; //100ns
	CAlgNode* n;
	int i;
	TestAlgList_Init();

	//test add head
	GetLocalTime(&st1);
	TestAlgList_AddAll_Pointer(1);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to add head %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	//iterate all elements
	GetLocalTime(&st1);
	CAlgList_Enum(g_CAlgList,TestAlgList_EnumNothing,0);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to iterate %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	i=0;
	GetLocalTime(&st1);
	ALGLIST_FOREACH(g_CAlgList, n);
	i++;
	ALGLIST_FOREACH_END();
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to iterate %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, i,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	//CAlgList_Enum(CAlgList_GetAlgFunc(),g_CAlgList,TestAlgList_Enum,0);
	//remove all 
	TestAlgList_RemoveHead();

	//test add tail
	GetLocalTime(&st1);
	TestAlgList_AddAll_Pointer(0);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to add tail %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);
	//CAlgList_Enum(CAlgList_GetAlgFunc(),g_CAlgList,TestAlgList_Enum,1);
	TestAlgList_RemoveTail();

	//test find and insert
	CAlgList_ReSet(g_CAlgList, sizeof(CAlgListNodeData));
	TestAlgList_Insert_Remove();

	TestAlgList_Free();
}
LinkList的一个简单实现
coding
06-05 964
链式线性表是数据结构里很简单但也是很常见的数据结构，相比顺序存储的线性表，可以更快的实现添加和删除操作，但读取速度比顺序结构会慢。链式线性表的关键在于，每个数据存储为节点形式。不仅仅保存有数据，还有一个引用“next”指向下一个节点。链式结构还可以再扩展为双向链表、循环链表等等。基本原理一样，只是增加了引用。下面就是最简单的链式线性表的实现的源代码，会有潜在的bug，但是不影响我们理解这种数据结构
2021-07-05 倒置链表（Cpp/C）
qq_43515555的博客
07-05 1220
倒置链表 以下题目节选自educoder #include "linklist.h" // 引用库函数文件 namespace exa { //请在命名空间内编写代码，否则后果自负 link l; // 定义指针型变量 void Print(link l) // 算法Print，依次访问每个元素结点 { link P; // 定义指针型变量 ____________
LinkList单链表
小麦大大博客
03-02 675
1、LinkList源码解释与测试 调试环境采用的是VS2015，大家可以选择自己合适的编译环境去调试。（先了解一些单链表，后面在写一篇STL，双向链表的源码） LinkList.h #ifndef MY_LINKLIST_H #define MY_LINKLIST_H #include<vector> #include<iostream> using namespace ...
数据结构单向循环链表的Linux Ubuntu 下的C语言实现
weixin_65155181的博客
07-29 657
好了，今天的分享结束了，今天的链表是单向奔赴，那有没有双向奔赴的链表呢？当然有，坤坤明天就告诉你，我是练习编程时长两年半的个人练习生昆工第一ikun，我们明天见。现在，有一部分练习时长超过两年半的ikun就要问了，线性链表不能从结尾遍历回来，我心里不舒服，用着也不好用，那么下面我就来给大家介绍单向循环链表。由于坤坤没有太多时间，而且主函数的菜单列表也比较简单，所以坤坤没有写出主菜单，只是把函数功能实现了一遍，希望大家多多包涵。单向循环链表与线性链表大体相同，只是把首尾连接了起来，请看代码。...
手写linklist demo
08-21
在本“手写linklist demo”中，我们将深入理解链表的原理，并通过编写代码来实现一个简单的链表示例。下面将详细讨论链表的基本概念、结构以及如何实现。 链表是一种线性数据结构，与数组不同，它不连续存储元素。...
用c写的一个linklist
03-03
用c写的一个linklistc程序设计链表
用c/c++自己动手实现一个链表LinkList
一只懒虫的博客
10-08 3779
链表的特点 便于插入删除，这些操作只要改变指针的指向 遍历查找O(n) 排序复杂度也极大 所以适合插入删除频繁的程序。 实现思想 自建基本的节点数据结构 明确基本操作：初始化、插入、删除、按位置查找、按值查找等等 实现代码 注：vs2008 // LinkList.cpp : Defines the entry point for the console application. //...
LinkList *L ， LinkList L， LinkList *&L 和 LinkList &*L区别及用法
zha_zha_zha_wa的博客
04-04 1万+
首先讲几个概念 a = 1 ,b = 2 viod swap(int i,int j) { int t; t = i; i = j; j = t; } swap(a,b) printf("%d,%d",a,b);\ //输出结果：1 2 该代码并不能交换a和b，因为参数传递的过程仅为值传递，在该代码中也就是将1赋值给i，2赋值给j，并在swap中交换i与j。 形参的交换并不能影响实参的...
ArrayList和LinkList的区别
m0_59002506的博客
06-28 7602
ArrayList和LinkList的区别 ArrayList的实现是基于数组来实现的，LinkedList的基于双向链表来实现。这两个数据结构的逻辑关系是不一样，当然物理存储的方式也会是不一样。 LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。 对于随机访问，ArrayList要优于LinkedList。 对于随机访问，ArrayList要优于LinkedList。 对于插入和删除操作，
数据结构与算法 - 线性表(完整代码)
JKR10000的博客
03-27 6125
样例输入: 3 //输入一个数a，后面将输入a个数据元素 8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3 3 //输入一个数b，后面将再输入b个数据元素 10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3 89 //删除一个值为89的结点 1 //删除1号结点 样例输出: 8 10 9 3 #inc...
C++实现单链表
meditator的博客
12-07 1307
1、头文件 创建LinkList.h头文件，一般类的声明和成员函数的实现都是分文件编写的，但这里用的是模板编程，就放在一个文件夹下了。 #pragma once template<class T> class LinkNode { template<class T> friend class LinkList; //将链式表类声明为友元 public: LinkNode() { next = NULL; //每new一个结点时，将他置空，串进链表才设ne
C++题集
董世磊(C/C++)
10-17 457
CC++ 题集(CC++试题和部分答案)1. 以下三条输出语句分别输出什么？[C易] char str1[]       = "abc"; char str2[]       = "abc"; const char str3[] = "abc";  const char str4[] = "abc";  const char* str5   = "abc"; const
C++/C++11中命名空间(namespace)的使用
热门推荐
网络资源是无限的
11-19 6万+
C++/C++11中命名空间(namespace)的使用
C++学习笔记 —— 命名空间、内联函数、按值/引用/指针传递
Charles Ren's Tech Blog
02-18 516
命名空间 为了解决命名冲突的问题。 比如说我调用一个方法名，比如说孙悟空，但是在我引用的头文件命名空间中存在两个文件都有sun这个方法。那么如果我们直接调用，计算机就不知道我们使用的是哪一个，就会报错。所以我们要指明。 #include <iostream> using namespace std; // 第一个命名空间 namespace LOL{ void su...
使用命名空间、头文件和实现文件
Wanda && Aidem
12-01 1735
2.3  使用命名空间、头文件和实现文件 使新的throttle类满足程序的需求将是非常有意义的(毕竟，我们绝不会知道何时将需要节流阀类)。我们将在此前提下继续完善throttle类，并隐藏类的实现细节。此外，也不应当使其他程序员担心他们自己选择的变量名称是否会碰巧与我们使用的名称发生冲突。 可以通过以下3个步骤来实现上述目标： (1) 创建命名空间。 (2) 编写头文件。 (3) 编写
C++命名空间namespace及using的使用
D_Sfei的博客
03-01 9677
命名空间（namespace）是C++语言特别重要的特性，当第三方供应商提供的库时，为了避免与其他供应商或者用户定义的名字相冲突（命名空间污染），常常将库的内容放置在自己独立的命名空间中。C++标准库也定义了相应命名空间std，用户在使用标准库时必须通过作用域运算符（::），或者使用using关键词来简化命名空间中名字的使用。命名空间的定义    C++通过作用域确定变量的访问权限，如全...
最全的C/C++面试题解（2）
雨中怡然
09-13 4704
1. 以下三条输出语句分别输出什么？[C易]char str1[] = "abc";char str2[] = "abc";const char str3[] = "abc"; const char str4[] = "abc"; const char* str5 = "abc";const char* str6 = "abc";cout cout cout 2. 非C
arraylist和linklist区别,写出代码
最新发布
05-24
### ArrayList 和 LinkedList 的区别 #### 1. 数据结构基础 ArrayList 是基于动态数组实现的，而 LinkedList 则是基于双向链表实现的。由于其底层数据结构的不同，在执行各种操作时两者的性能差异显著。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值