C++基础

已于 2022-08-06 11:20:55 修改
阅读量207 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2022-08-06 11:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y1355966/article/details/126181497
版权

目录

命名空间

  • 使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染

命名空间定义

  • 定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接一对 {} 即可，{} 中即为命名空间的成员
//1. 普通的命名空间
namespace N1{   // N1为命名空间的名称
    // 命名空间中的内容，既可以定义变量，也可以定义函数
    int a;
    int Add(int left, int right)
    {
        return left + right;
    }
}
//2. 命名空间可以嵌套
namespace N2{
    int a;
    int b;
    int Add(int left, int right){
        return left + right;
    }
    namespace N3{
        int c;
        int d;
        int Sub(int left, int right){
            return left - right;
        }
    }
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1{
    int Mul(int left, int right){
        return left * right;
    }
}

命名空间使用

  • 加命名空间名称及作用域限定符
int main(){
    printf("%d\n", N1::a);
    return 0;
}
  • 使用using将命名空间中成员引入
using N2::b;
int main(){
    printf("%d\n", b);
    return 0;
}
  • 使用using namespace 命名空间名称引入
using namespce N1;
int main(){
    Add(10, 20);
    return 0;
}

使用命名空间注意事项
1.避免在项目中使用using namespace std;
2.日常练习可使用using namespace std;
3.项目中，指定命名空间访问和展开常用命名空间

指定命名空间访问

#include <vector>
int main() {
    // 指定命名空间访问
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    return 0;
}

展开常用命名空间

using std::cout;
using std::endl;
int main() {
    //展开后使用
    cout << "hello world" << endl;
    return 0;
}

输入输出

  • 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含 头文件以及std标准命名空间。
  • 使用C++输入输出更方便自动识别类型，不需增加数据格式控制，比如：整形–%d，字符–%c
#include <iostream>
using namespace std;
int main(){
    int a;
    double b;
    char c;
    // >> 流提取运算符
    cin >> a;
    cin >> b >> c;
    // << 流插入运算符
    cout << a << endl;
    cout << b << " " << c << endl;
    // endl 等同于 \n
    return 0;
}

缺省参数

缺省参数定义

  • 缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参
  • C语言不支持缺省参数
  • 缺省值必须是常量或者是全局变量

缺省参数分类

  • 全缺省
void Func(int a = 0,int b = 1) {
    cout << "a = " << a << endl;
    cout << "b = " << b << endl << endl;
}
  • 半缺省

1.从右往左连续缺省，不可间隔， 如想缺省a，就必须缺省b
2.参数传递是从左往右，不可跳传， 如想传参给b,就得传递给a，Func2(,2)是错误的

void Func2(int a , int b = 1) {
    cout << "a = " << a << endl;
    cout << "b = " << b << endl << endl;
}
int main() {
    Func(1,2);
    Func2(2);	
    // Func2(,2);  // err
    Func();
    return 0;
}

缺省参数应用举例

  • 注意：缺省参数不能同时在声明和定义同时出现，因此分离定义时候，在声明函数处，给缺省参数

Stack.h

struct Stack {
	int* a;
	int top;
	int capacity;
};
void StackInit(struct Stack* ps, int capacity = 4); // 半缺省

Stack.cpp

void StackInit(struct Stack* ps, int capacity) {
	ps->a = (int*)malloc(sizeof(int) * capacity);
	ps->top = 0;
	ps->capacity = capacity;
}

main.cpp

#include <iostream>
#include "Stack.h"
using namespace std;
int main(){
    struct Stack st1;
    StackInit(&st1);
    struct Stack st2;
    StackInit(&st2, 40);
    return 0;
}

函数重载

函数重载定义

  • 在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表 (参数个数 或 类型 或 顺序)必须不同 ，常用来处理实现功能类似数据类型不同的问题
  • 返回值不同不构成重载
short Add(short left, short right){
	 return left + right;
}
int Add(short left, short right){
	 return left + right;
}

引用

引用概念

  • 引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间
int main() {
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
    return 0;
}

引用特性

  • 引用在定义时必须初始化
  • 一个变量可以有多个引用
  • 引用一旦引用一个实体，再不能引用其他实体
int main() {
    int a = 1;
    // 引用在定义时必须初始化
    // int& b;  // err

    // 一个变量可以有多个引用
    int& b = a;
    int& c = a;
    int& d = b;
    // 引用一旦引用一个实体，再不能引用其他实体
    int x = 10;
    b = x;
    return 0;
}

常引用

void main(){
    const int a = 10;
    //int& ra = a; // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
    return 0;
}
  • 权限不能放大，即一个 const 修饰的变量不能被一个不被 const 修饰的变量引用，如下
    const int b = 10;
    int& c = b;     // 报错
  • 权限可缩小
    int b = 10;
    const int& c = b;     // 正确
  • 隐式类型转换会产生临时变量，临时变量具有常性，不同类型变量引用时，需要加 const
int main() {
	int i = 1;
	double d = i;	// 隐式类型转换
	const double& rd = d;   // 正确
    // double& rd = i;  // 错误原因如下
	// 不能权限放大，因为临时变量的属性是const double
	double d2 = (double)i;
	// 强制类型转换不改变i的原属性
	double& rd2 = d2;
	return 0;
}
  • 如果使用引用传参，函数内不改变n，那么建议尽量用 const 引用传参
void func1(int& a) {
}
void func2(const int& a) {
}
int main() {
	int a = 10;
	const int b = 20;
	double c = 30.1;
	func1(a);
	// func1(b);    // 权限放大
	// func1(1.11); // 权限放大
	// func1(c);    // 权限放大
	func2(a);
	func2(b);
	func2(1.11);
	func2(c);
	return 0;
}

引用的使用场景

  • 作参数

作为输出型参数

void Swap(int& left, int& right){
	int temp = left;
	left = right;
	right = temp;
}
int main() {
	int a = 1, b = 2;
	Swap(a, b);
	return 0;
}

大对象传参时，传引用能提高效率

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main() {
	TestRefAndValue();
	return 0;
}

在这里插入图片描述

  • 做返回值

输出型返回对象，调用者可以修改返回对象

  • 由于传值返回的本质是——生成一个返回对象拷贝作为函数调用的返回值。当调用者要修改返回对象时，需要使用传引用返回
  • 传引用返回的本质是——返回返回对象的别名，因此为了防止对象被销毁，需要让对象储存在静态区

减少拷贝，提高效率

int& Count(){
	static int n = 0;	// 这样才能正确使用传引用返回
    n++;
	return n;
}
int main() {
	int ret = Count();
	cout << ret << endl;
	printf("%d\n", ret);
	return 0;
}

引用实现修改顺序表数据

SeqList.h

typedef struct SeqList {
	int* a;
	int size;
	int capacity;
}SL;
void SLInit(SL& s, int capacity = 4);
void SLPushBack(SL& s, int x);
int& SLAt(SL& s, int pos);

SeqList.cpp

void SLInit(SL& s, int capacity) {
	s.a = (int*)malloc(sizeof(int) * capacity);
	s.size = 0;
	s, capacity = capacity;
}
void SLPushBack(SL& s, int x) {
	if (s.size == s.capacity) {
		int* tmp = (SL*)realloc(s, (s->capacity+3) * sizeof(SL));
        if(NULL != tmp){
            s->a = tmp;
            s->capacity +=3;
        }
        else{
            perror("SLPushBack::realloc");
            return;
        }
	}
	s.a[s.size++] = x;
}
int& SLAt(SL& s, int pos) {
	assert(pos >= 0 && pos <= s.size);
	return s.a[pos];
}

main.cpp

int main() {
	SL sl;
	SLInit(sl);
	SLPushBack(sl, 1);
	SLPushBack(sl, 2);
	SLPushBack(sl, 3);
	SLPushBack(sl, 4);
	for (int i = 0; i < sl.size; i++) {
		cout << SLAt(sl, i) << " ";
	}
	cout << endl;
	SLAt(sl, 0)++;
	for (int i = 0; i < sl.size; i++) {
		cout << SLAt(sl, i) << " ";
	}
	cout << endl;
	SLAt(sl, 0) = 10;
	for (int i = 0; i < sl.size; i++) {
		cout << SLAt(sl, i) << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下
在这里插入图片描述

引用与指针的区别

指针和引用用途基本是相似的
链表实现只能使用指针
语法角度，引用不开辟新的空间，指针开辟4或者8字节的空间；而底层角度，引用是按照指针的方式实现

  • 语法层面区别如下
  1. 引用在定义时必须初始化，指针没有要求
  2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
  3. 没有NULL引用，但有NULL指针
  4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
  5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  6. 有多级指针，但是没有多级引用
  7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  8. 引用比指针使用起来相对更安全

内联函数

内联函数概念

  • 以 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率

C++面对短小的函数，频繁的调用的情况，使用内联函数提升程序运行的效率

C语言面对短小的函数，频繁的调用的情况，则使用宏函数

宏优点：

  1. 复用性强
  2. 提高效率，减少栈帧建立。

宏缺点：

  1. 不方便调试宏。（因为预编译阶段进行了替换）
  2. 导致代码可读性差，容易误用
  3. 没有类型安全的检查

内联函数的特性

  • C++建议使用inline/const/enum替换宏，inline几乎解决了所有宏的缺点
  1. inline是一种以空间换时间的做法，省去调用函数额开销
  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体函数内部实现代码指令长度较长或者使用递归等等，编译器优化时会忽略掉内联
  1. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到
// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i){
	cout << i << endl;
}
// main.cpp
#include "F.h"
int main(){
	f(10);
	return 0;
}

链接错误：main.obj : error LNK2019: 无法解析的外部符号 “void __cdecl f(int)” (?f@@YAXH@Z)，该符号在函数 _main 中被引用

auto关键字

  • 自动推导变量类型
  • 使用auto定义变量时必须对其进行初始化
int TestAuto(){
    return 10;
}
int main(){
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = TestAuto();
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    cout << typeid(d).name() << endl;
    //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    return 0;
}

auto使用场景

  • 自动迭代

前提知识：范围for语法—>for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围

int main() {
    int a[] = { 0,1,2,3,4,5,6,7,8,9 };
    // 常规用法
    for (int i = 0; i < 10; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    // auto用法
    // 自动一次取a的数据赋给e
    // 自动迭代，自动判断结束
    for (auto e : a) {
        cout << e << " ";
    }
    cout << endl;
}
  • 类型较长时，auto自动推导
int main() {
    // 类型较长时，auto自动推导
    map<string, string> dict;
    auto it = dict.begin();
    return 0;
}

auto使用细则

  • auto与指针和引用结合使用，auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
int main() {
    int a[] = { 0,1,2,3,4,5,6,7,8,9 };
    // 自动一次取a的数据赋给e
    // 自动迭代，自动判断结束
    for (auto& e : a) {
        e++;
        cout << e << " ";
    }
    cout << endl;
    }
  • 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
void TestAuto(){
    auto a = 1, b = 2;
    auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

auto不能推导的情景

  • auto不能作为函数的参数
void TestAuto(auto a){}
  • auto不能直接用来声明数组
void TestAuto(){
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

nullptr关键字

  • 使用 nullptr 关键字表示指针空值

因为NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量

void f(int){
cout<<"f(int)"<<endl;
}
void f(int*){
cout<<"f(int*)"<<endl;
}
int main(){
    f(0);
    f(NULL);
    f((int*)NULL);
    return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下
将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。

萦流涨清深
关注
专栏目录
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
c++基础教程
04-18
本教程“C++基础教程”旨在帮助初学者掌握C++编程的基本概念和技术，为后续深入学习打下坚实的基础。 一、C++语言概述 C++是由Bjarne Stroustrup在C语言的基础上扩展而来的，它引入了类和对象的概念，支持面向对象...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
c++基础与提高
01-17
C++基础与提高文档可能还包括了关于类成员函数的存储方式，即成员函数是如何在类中存储的，以及如何通过指针来访问类的成员函数。此外，文档还可能包含一些编程实践案例，比如如何实现一个钟表类，以及对系统标准库...
c++基础程序文件
03-09
c++基础学习，可以促进对c++编辑软件的认识，增强学习的兴趣
C++ 基础.png
07-13
C++基础知识框图，个人必备基础知识，用于复习，备考，找工作等等都有帮助，帮助萌新梳理知识点，帮助大佬温习知识点，本人费心整理的，希望大家喜欢。
C++基础笔记资料.zip
07-22
这份"C++基础笔记资料.zip"包含的资源是学习C++基础知识的重要参考资料，适合初学者和有一定经验的开发者用来巩固基础。 C++起源于C语言，由Bjarne Stroustrup在1979年开发，旨在增加程序的抽象层次和类型安全性。...
c++基础与提高.rar
07-19
本教程“C++基础与提高”旨在帮助学习者从零开始掌握C++的基础知识，并进一步提升技能，实现对C++的深入理解和熟练运用。 一、C++基础 1. **语法结构**：C++的语法结构基于C语言，包括变量声明、数据类型（如int、...
c++基础知识
12-28
c++基础知识，关于数据类型、常量、变量等C++基础知识的介绍
C++基础学习上机试题整理(66题)
09-26
这份"**C++基础学习上机试题整理(66题)**"是为初学者设计的一系列练习，旨在帮助他们深入理解C++的基础概念，并通过实际编程来提升技能。 一、循环语句 循环语句在C++中是控制程序流程的关键部分，包括for循环、...
c++基础课件
03-15
c++基础课件，！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
C++基础教程_完整版 - 副本.pdf
11-23
C++基础教程 本教程是对 C++语言的深入浅出的介绍，从基础知识到 ANSI-C++标准的最新功能，内容涵盖了从数组、类等基本概念到多态、模板等高级概念。本教程共分 6 章，每章分若干小节，每一小节都结合了可以工作的...
C++基础培训.zip
05-07
C++基础培训旨在帮助初学者理解并掌握C++语言的基本概念和编程技巧，为进阶学习和实际开发打下坚实的基础。在这个压缩包文件中，我们可以期待找到一系列关于C++入门的学习材料。 首先，C++语言的基础包括语法结构、...
C++基础C++基础入门.md
04-10
C++基础C++基础入门.md
C++基础知识总结
07-25
### C++基础知识总结 #### 一、C++数据和变量的类型及变量作用域 **1. 基本的内置类型** C++提供了一系列基本的内置数据类型，用于存储不同种类的数据。以下是一些常见的类型及其特点： - **布尔型 (`bool`)**：...
由浅入深学C++基础进阶与必做300题 源程序
07-14
由浅入深学C++基础进阶与必做300题 源程序 解压后122M C++是近年广泛使用的程序设计语言，由C语言的基础上发展而来，实现 了由面向过程到面向对象的转变，全面支持面向对象的程序设计方法。C++ 语言在软件工业领域...
C++基础与提高-王桂林-4rd.pdf
06-07
根据提供的文件信息，以下是...王桂林的《C++基础与提高》作为教材，能够为读者提供系统性的C++语言学习和深入讨论。通过学习这些知识，读者能够掌握C++语言的核心特性和编程技术，为进一步的软件开发打下坚实的基础。
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
最新发布
shanshan的博客
11-11 501
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++基础教程与ACM算法解析
“c++基础与ACM题解”是一本针对C++初学者的教程，涵盖了C++的基础知识和算法应用，特别适合准备参加ACM（国际大学生程序设计竞赛）的学习者。 本书详细介绍了C++语言的基本概念和语法，从程序设计的基础出发，讲解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值