【C++】入门基础（上）

已于 2024-09-11 21:28:12 修改
阅读量658 收藏 17
点赞数 19
分类专栏： C++ 文章标签： c++ 开发语言 笔记 算法
于 2024-09-11 21:23:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lrq13965748542/article/details/142028532
版权

Hi，好久不见！

目录

1、C++入门小基础 

1.1  祖师爷--Bjarne Stroustrup（本贾尼·斯特劳斯特卢普）

1.2  C++参考文献

1.3  书籍推荐

2、C++的第一个程序

3、命名空间

3.1  namespace的价值

3.2  namespace的定义

3.3  命名空间的使用

4、C++输入和输出

5、缺省参数

6、函数重载

7、引用

7.1  引用的概念和定义

7.2  引用的特性

7.3  引用的使用

Relaxing Time ~~~

             ——————————《壁上观》——————————

正文开始——

1、C++入门小基础 

1.1  祖师爷--Bjarne Stroustrup（本贾尼·斯特劳斯特卢普）

1.2  C++参考文献

参考资料 - C++ 参考资料 (cplusplus.com)

C++ 参考手册 - cppreference.com

cppreference.com

提示：第一个链接不是C++官方文档，标准也只是更新到C++11，但是以头文件形式呈现，内容比较易看好懂，后两个链接分别是C++官方文档的中文版和英文版，信息很全，更新到了最新的C++标准，没有第一个那么易看，各有优点，相互结合使用即可。

1.3  书籍推荐

《C++ Primer》：主要讲解语法，是一本经典的语法书籍，前中后期都可以看。

《STL源码剖析》：主要从底层实现的角度结合STL源码，庖丁解牛式剖析STL的实现。很好的帮助我们学习别人用语法是如何实现出简洁高效的数据结构和算法代码，如何使用泛型封装等。让我们不再坐井观天、闭门造车。建议中后期看。

《Effective C++》：这本书主要讲解了55个如何正确高效使用C++的条款，建议中后期看一遍，工作一两年后再看一遍，会有不一样的收获。

2、C++的第一个程序

C++兼容C语言绝大多数语法，所以C语言实现的hello world依旧可以运行，C++需要把定义文件代码后缀改成.cpp，vs编译器看到是.cpp就会调用C++编译器编译，linux下要用g++编译，不再是gcc。

C++也有一套自己的输入输出，严格说C++版本的hello world应该像下面这样写：

#include<iostream>
using namespace std;

int main()
{
	cout << "hello world" << endl;

	return 0;
}

3、命名空间

3.1  namespace的价值

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

C语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决这样的问题。

#include<stdio.h>
#include<stdlib.h>

//文件在与预处理阶段会展开<stdlib.h>,里面包含以rand命名的函数，此时与我们定义的rand就会冲突

int rand = 100;
int main()
{
    printf("%d\n",rand);
    return 0;
}

3.2  namespace的定义

  1. 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}，里面即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
  2. namespace本质是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，同一个域不可以定义同名变量。所以下面的rand不再冲突了。
  3. C++域中有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找一个变量/函数/类型出处（声明和定义）的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不会影响变量生命周期。
  4. namespace只能定义在全局，不能定义在局部（例如不能在main函数里面定义）。当然它还可以嵌套定义使用，甚至多层嵌套。
  5. 项目工程中多文件中定义的同名namespace会认为是一个namespace，不会冲突。
  6. C++标准库都放在一个叫std（standard）的命名空间。
#include<stdio.h>
#include<stdlib.h>

//1.正常的命名空间的定义

//lrq是命名空间的名字(我选的名字缩写)，一般开发者是用项目名字作命名空间名
namespace lrq
{
	//命名空间中可以定义变量/函数/类型
	int rand = 100;

	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

int main()
{
	//这里默认访问的是全局的rand函数指针
	printf("%p\n", rand);

	//这里指lrq命名空间里面的rand，::是域作用限定符，指定lrq空间里面的rand
	printf("%d\n", lrq::rand);
    lrq::Add(1,2);
    //注意这里::的位置
    struct lrq::Node node;

	return 0;
}

//2.命名空间可以嵌套
namespace lrq
{
	//1号
	namespace one
	{
		int rand = 99;

		int Add(int left, int right)
		{
			return left + right;
		}
	}

	//2号
	namespace two
	{
		int rand = 88;

		int Add(int left, int right)
		{
			return left * right;
		}
	}
}

int main()
{
	printf("%d\n", lrq::one::rand);99
	printf("%d\n", lrq::two::rand);88

	printf("%d\n", lrq::one::Add(1,2));相加
	printf("%d\n", lrq::two::Add(1,2));相乘

	return 0; 
}

//多文件中可以定义同名namespace，它们会默认合并到一起，就像同一个namespace一样


//不同的域可以定义同名变量，同一个域不可以定义同名变量

int x=1;

namespace lrq
{
    int x=2;
    return 0;
}

void func()
{
    int x=3;
}

int main()
{
    int x=4;

    printf("%d\n",x);//x=4
    printf("%d\n",lrq::x);//x=2
    printf("%d\n",::x);//此时默认访问的是全局的
    //无法访问func里面的。局部的只能在局部访问

    return 0;
}
//这里不会冲突，在main函数里面，默认到局部去找，再到全局去找，命名空间里面要指定去找x

3.3  命名空间的使用

编译查找一个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去找。所以下面程序会编译报错，。所以我们要使用命名空间中定义的变量/函数，有三种方式：

  1. 制定命名空间访问，项目中推荐这种方式；
  2. using将命名空间中的某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式；
  3. 展开命名空间的全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。
#include<stdio.h>

namespace lrq
{
	int a = 0;
	int b = 2;
}

int main()
{
	//编译报错，“a”：未声明的标识符
	printf("%d\n", a);

	//指定命名空间访问
	printf("%d\n", lrq::a);

	return 0;
}

//using将命名空间中的某个成员展开
using lrq::b;
int main()
{
	printf("%d\n", b);

	return 0;
}

//展开命名空间中的全部成员
using namespace lrq;
int main()
{
	printf("%d\n", a);
	printf("%d\n", b);

	return 0;
}

4、C++输入和输出

  • <iostream>是 Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
  • std::cin 是 istream 类的对象，它主要面向窄字符（narrow characters （of type char））的标准输入流。
  • std::cout 是 ostream 类的对象，它主要面向窄字符的标准输出流。（输入输出，字符串->整型等类型->字符流输出到终端）。
  • std::endl 是一个函数，流插入输出时，相当于插入一个换行字符加刷新缓冲区。
  • <<是流插入运算符，>>流提取运算符。（C语言还用这两个字符做位运算左移/右移）。
  • 使用C++输入、输出更方便，不需要像 printf/ scanf 输入输出时那样，需要手动指定格式，C++的输入输出可以自动识别变量类型（本质是通过函数重载实现的，这个后面讲解），其实最重要的是C++的流能更好的支持自定义类型对象的输入输出。
  • IO流涉及类和对象，运算符重载，继承等很多面向对象的知识，后面再详细学习介绍。
  • cout/ cin/ endl 等都属于C++标准库，C++标准库都放在一个叫std（standard）的命名空间中，所以要通过命名空间的方式去使用它们。
  • 一般日常来练习中我们可以使用 using namespace std，实际项目开发中不建议 using namespace std。
  • 这里我们没有包含 <stdio.h> 也可以使用 printf 和 scanf，在包含 <iostream> 就间接包含了<stdio.h>。VS系列编译器是这样的，其他编译器可能会报错。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	double b = 100.0;
	char c = 'a';
    
    cout<<"hello world\n";//字符串后面加个\n，直接换行
    //支持连续的流插入，即使不同类型
	
	cout << a << " " << b << " " << c << " " << endl;//换行，推荐使用endl
	std::cout << a << " " << b << " " << c << " " << std::endl;//即使展开std，也可以写std::

	scanf("%d%lf", &a, &b);
	printf("%d %lf\n", a, b);//如果要求位数，推荐用printf

	//可以自动识别变量的类型
	cin >> a;
	cin >> b >> c;

	cout << a << endl;
	cout << b << " " << c << endl;

	return 0;
}
#include<iostream>
using namespace std;

//对于cout，流插入的东西不会直接到终端，而是先到一个缓冲区，有了刷新标志才会出现在终端

int main()
{
	//在io需求比较高的地方，如部分大量输入的竞赛题中，加上下面3行代码
	//可以提高C++IO效率
	ios_base::sync_with_stdio(false);//取消c和c++的兼容
	cin.tie(nullptr);
	cout.tie(nullptr);
    
    return 0;
}

5、缺省参数

  • 缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（有些地方也把缺省参数也叫默认参数）。
  • 全缺省就是有多个形参，全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
  • 带缺省参数的函数调用，C++规定必须从左往右依次给实参，不能跳跃给实参。
  • 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

【注意】

函数声明就是只有函数的返回值，名称和参数，简单理解就是没有{}的函数；函数定义就是函数带着实现{}。

声明和定义只有一个地方可以有缺省值就比如：
int add(int a, int b);

int add(int a = 1, int b = 2) {
    return a+b;
}

这个声明和定义只能有一个地方设置缺省值。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;

void Func(int a = 0)
{
	cout << a << endl;
}

int main()
{
	Func();  //没有传参时，使用参数的默认值
	Func(10);//传参时，使用指定的实参

	return 0;
}
#include<iostream>
using namespace std;

//全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl << endl;

}

//半缺省，缺省值必须要从右往左给

void Func2(int a, int b = 10, int c = 20)
{

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl << endl;

}

int main()
{
    //实参必须从左往右给

	Func1();//全部用缺省值
	Func1(1);//后两个用缺省值
	Func1(1, 2);
	Func1(1, 2, 3);//不使用缺省值
    Func1(,2,);//不支持这种

	Func2(100);
	Func2(100, 200);
	Func2(100, 200, 300);

	return 0;
	
}
//缺省参数的实际意义举例

//Stack.h
#include<iostream>
#include<assert.h>
using namespace std;

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;
	int capacity;
}ST;

void STInit(ST* ps, int n = 4);

//Stack.cpp
#incldue"stack.h"
//缺省参数不能声明和定义同时给

void STInit(ST* ps, int n)
{
	assert(ps && n > 0);

	ps->arr = (STDataType*)malloc(n * sizeof(STDataType));
	ps->top = 0;
	ps->capacity = 0;

}

//test.cpp
#incldue"Stack.h"
int main()
{
	ST s1;
	STInit(&s1);

	//确定知道要插入1000个数据，初始化一下开辟好，避免扩容
	ST s2;
	STInit(&s2,1000);

	return 0;
}

6、函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数的个数不同或者类型不同。这样C++调用就出现了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数的。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;

	return left + right;
}

double Add(double left, double right)
{
	cout << "int Add(double left, double right)" << endl;

	return left + right;
}

//2、参数个数不同
void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(int a)" << endl;
}

//3、参数类型顺序不同,本质还是参数类型不同
void f(int a, char b)
{
	cout << "f(int a, char b)" << endl;
}

void f(char a, int b)
{
	cout << "f(char a, int b)" << endl;
}

int main()
{
	Add(10, 20);
	Add(10.1, 20.2);

	f();
	f(10);

	f(10, 'a');
	f('a', 10);

	return 0;

}


//返回值不同不能作为重载条件，因为调用时也无法区分
void f()
{
	//...
}

int f()
{
	//...
	return 0;
}

//下面两个函数构成重载,参数不同
//f()但是调用时会报错，存在歧义，编译器不知道调用谁
void f1()
{
	cout << "f()" << endl;
}

void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f1();//没有参数
	f1();//没有传参，用缺省值
}

7、引用

7.1  引用的概念和定义

引用不是定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间。比如：马铃薯，也叫土豆。

类型&  引用别名=引用对象。

C++中为了避免引入太多运算符，会复用C语言的一些符号，比如前面的<<、>>，这里引用也和取地址操作符使用了同一个符号&。

【区分】

#define  N  10（定义一个常量，在预处理阶段把N替换成10）；

typedef 是给类型取别名；

类型& 是给变量取别名。

#include<iostream>
using namespace std;

int main()
{
	int a = 0;

	//引用：b和c是a的别名
	int& b = a;
	int& c = a;
	//也可以给b取别名d，d也相当于是a的别名
	int& d = b;
    
    //这里a，b，c的值都会+1
	d++;

	//这里是取地址,取得都是一样的地址，因为它们共用一块内存空间
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;

	return 0;
}

直观看出a,b,c,d之间的底层逻辑，见下图： 

7.2  引用的特性

  • 引用在定义时必须初始化；
  • 一个变量可以有多个引用；
  • 引用一旦引用一个实体，再不能引用其他实体。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

int main()
{
	int a = 10;

	//编译报错：“ra”：必须初始化引用
	//int& ra;

	int& b = a;
	int c = 20;
	//这里并非让b引用c，因为C++引用不能改变指向
	//这里是一个赋值
	b = c;

	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;

	return 0;

}

7.3  引用的使用

  • 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象；
  • 引用传参和指针传参功能是类似的，引用传参相对方便一点；
  • 引用返回值的场景相对比较复杂，后续再讲解；
  • 引用和指针在实践中相辅相成，功能有重叠性，但各有特点，互相不可替代。C++的引用跟其他语言的引用（如Java）是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向，Java的引用可以改变指向。
  • 一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>

using namespace std;

//这里rx，ry就相当于x和y的别名，不需要再传地址了
void Swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
} 
int main()
{
	int x = 0, y = 1;
	cout << x << " " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}
#include<iostream>
using namespace std;
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
} 

// 栈顶
void STPush(ST& rs, STDataType x)
{
	// 满了， 扩容
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		rs.a = tmp;
		rs.capacity = newcapacity;
	}
	rs.a[rs.top] = x;
	rs.top++;
}

// int STTop(ST & rs)
int& STTop(ST& rs)
{
	assert(rs.top > 0);
	return rs.a[rs.top];
}

int main()
{
	// 调⽤全局的
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;

	STTop(st1) += 10;
	cout << STTop(st1) << endl;
	return 0;
}

#include<iostream>
using namespace std;
typedef struct SeqList
{
	int a[10];
	int size;
}SLT;

// ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复
//杂的指针，但是很多同学没学过引⽤，导致⼀头雾⽔。

void SeqPushBack(SLT& sl, int x)
{}
typedef struct ListNode
{
	int val;
	struct ListNode* next;
}LTNode, *PNode;
PNode就相当于typedef struct ListNode*;

// 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量plist取别名
// 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
//void ListPushBack(LTNode** phead, int x)
//void ListPushBack(LTNode*& phead, int x)
void ListPushBack(PNode& phead, int x)
{
	PNode newnode = (PNode)malloc(sizeof(LTNode));
	newnode->val = x;
	newnode->next = NULL;
	if (phead == NULL)
	{
		phead = newnode;
	}
	else
	{
		//...
	}

}

int main()
{
	PNode plist = NULL;
	ListPushBack(plist, 1);
	return 0;
}

明天继续！ 

Relaxing Time ~~~

壁上观_一棵小葱、张曦匀_高音质在线试听_壁上观歌词|歌曲下载_酷狗音乐酷狗音乐为您提供由一棵小葱、张曦匀演唱的高清音质无损壁上观mp3在线听,听壁上观,只来酷狗音乐!icon-default.png?t=O83Ahttps://t4.kugou.com/song.html?id=4kyjvedCRV2

             ——————————《壁上观》——————————

至此结束

我是云边有个稻草人

期待我们的下一次相遇——

云边有个稻草人
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
C++入门基础(万字总结）（建议收藏！！！）
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础入门（超详细）
热门推荐
qq_44859533的博客
07-02 6万+
全网很全的C++基础入门，针对每一个概念以及概念之后的代码实现运行结果。可以帮助新手很快上手，也可以帮助老手回顾C++。
c++入门基础（基础语法）
weixin_46836127的博客
11-25 4402
一个变量相当于输出一个点，一个循环相当于输出一条线，双重循环相当于输出一个平面，三重循环相当于输出一个立体图形。总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间。表达式3){ // 表达式2为真继续循环，否则结束循环。4 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上。while( 循环条件 ){ // 条件为真继续循环，否则结束循环。
C++基础入门
a577715979的博客
01-02 5567
C++入门
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础入门教程C++基础入门教程C++基础入门教程C++基础入门教程C++基础入门教程.txt
05-07
### C++基础入门教程 #### 1. C++初识 C++是一种广泛使用的面向对象的编程语言，它结合了高效性与强大的功能，适用于多种应用场景，如游戏开发、系统软件编写等。对于初学者来说，掌握C++的基础是非常重要的。 ##...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++基础入门.md.pdf
04-19
C++是一种静态类型、编译式、通用的编程语言，由Bjarne Stroustrup在1979年开始开发，最初被称为C with Classes，...以上内容为C++程序开发的基础知识。掌握这些知识点对于编写C++程序和进一步学习该语言是非常重要的。
【C++】STL—vector的使用
2301_77112794的博客
09-04 716
本文介绍了vector重点函数接口的使用
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 518
C语言 | Leetcode C语言题解之第389题找不同
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 294
QWidget(c++)嵌入window环境的exe
C语言——strcpy、sprintf与memcpy
最新发布
鲸落博客
09-09 1074
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C语言作用域
天道酬勤
09-07 967
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 936
💫往期文章👇：
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1081
C++复习参考文，待完善
c++ 类的继承详解
HJQD777的博客
09-07 484
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
【启明智显技术分享】探讨CAN总线相关知识以及Model3C 2路CAN的应用
ami82的博客
09-05 661
通信错误：由于CAN总线上的节点之间存在不同的优先级，可能导致数据冲突。总线阻塞：在某些情况下，CAN总线上的节点可能会长时间保持发送状态，从而导致其他节点无法发送数据，这种现象被称为总线阻塞。总线干扰：CAN总线可能会受到外部电磁干扰，如电源干扰、射频干扰等，这些干扰可能导致总线上的数据传输出错。总线过载：当CAN总线上的节点数量过多或者通信数据量过大时，可能导致总线过载，从而影响通信性能和稳定性。总线错误：CAN总线上的节点可能会发生硬件故障，例如控制器损坏、接口损坏等，这些情况都可能导致总线错误。
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
填坑之路
09-06 622
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

云边有个稻草人

您的鼓励是我最大的动力，感谢

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

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

打赏作者

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

抵扣说明：

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

余额充值