【C++】入门基础知识概括

已于 2022-03-06 16:27:59 修改
阅读量597 收藏 5
点赞数 7
分类专栏： C++ 文章标签： c++ 开发语言 后端
于 2022-02-11 18:21:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57018588/article/details/122830438
版权

目录


秃头侠们好呀，今天咱们来聊聊 C++入门基础

本章重点

  1. C++关键字
  2. 命名空间
  3. C++输入 输出
  4. 缺省参数
  5. 函数重载
  6. 引用
  7. 内联函数
  8. auto关键字
  9. 基于范围的for循环
  10. 空指针nullptr

C++关键字

C++总计63个关键字，C语言32个关键字

C++关键字如下
在这里插入图片描述这里就不一一讲解了，后续文章都会逐个提到。

命名空间

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

命名空间定义

定义命名空间，需要使用到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;
	}
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

命名空间使用

namespace N
{
	int a = 10;
	int b = 20;
	int Add(int left, int right)
	{
		return left + right;
	}
	int Sub(int left, int right)
	{
		return left - right;
	}
}
int main()
{
	printf("%d\n", a); // 该语句编译出错，无法识别a
	return 0;
}

命名空间的使用有三种方式：

  • 加命名空间名称及作用域限定符
    （指定作用域，做到了最好的隔离，但使用不方便）
int main()
{
printf("%d\n", N::a);
return 0;
}
  • 使用using将命名空间中成员引入
    （用于展开命名空间中常用的，此种方法较为推荐）
using N::b;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
return 0;
}
  • 使用using namespace 命名空间名称引入
    (这种方法是直接展开N，用起来方便，但失去了隔离的效果)
using namespce N;
int main()
{
printf("%d\n", N::a);
printf("%d\n", b);
Add(10, 20);
return 0;
}

C++输入&输出

#include<iostream>
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}

cout << 是标准输出也称为流插入
cin>> 是标准输入也称流提取

注意：使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及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;
return 0;
}

缺省参数

缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

void TestFunc(int a = 0)
{
cout<<a<<endl;
}
int main()
{
TestFunc(); // 没有传参时，使用参数的默认值
TestFunc(10); // 传参时，使用指定的实参
}

缺省参数分类

  • 全缺省参数
void TestFunc(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
  • 半缺省参数（部分缺省）
void TestFunc(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}

注意：

  1. 半缺省参数必须从右往左依次来给出，不能间隔着给
  2. 缺省参数不能在函数声明和定义中同时出现
//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 20)
{}
// 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。
  1. 缺省值必须是常量或者全局变量
  2. C语言不支持（编译器不支持）

函数重载

函数重载概念

函数重载: 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题

int Add(int left, int right)
{
return left+right;
}
double Add(double left, double right)
{
return left+right;
}
long Add(long left, long right)
{
return left+right;
}
int main()
{
Add(10, 20);
Add(10.0, 20.0);
Add(10L, 20L);
return 0;
}

下面两个函数属于函数重载吗？

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

答案：不属于
函数重载与返回参数类型无关
只与参数个数，类型，顺序有关

名字修饰

为什么C++支持函数重载，而C语言不支持函数重载呢？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：
预处理、编译、汇编、链接
在这里插入图片描述

  1. 实际我们的项目通常是由多个头文件和多个源文件构成，而通过我们C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
  2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
  3. 那么链接时，面对Add函数，连接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
  4. 由于Windows下vs的修饰规则过于复杂，而Linux下gcc的修饰规则简单易懂，下面我们使用了gcc演示这个修饰后的名字。
  5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成
    【_Z+函数长度+函数名+类型首字母】

采用C语言编译器编译后结果：
在这里插入图片描述
结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

采用C++编译器编译后结果：
在这里插入图片描述结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

通过这里我们就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载

另外我们也理解了，为什么函数重载要求参数不同！而跟返回值没关系。、

extern “C”

⭐在一些情况下，比如我用C++写的程序，需要调一个数据结构栈，但是这个栈是用C语言实现的，那么我们怎么办呢？

1、我们创建一个工程，创建C的静态库（这里我用VS2019举例）
在这里插入图片描述在这里插入图片描述

静态库不用写主函数，编译生成的是一个.lib文件
2、在这个静态库，实现一下Stack.h和Stack.c
在这里插入图片描述3、然后我们再创建一个正常的C++工程
这个工程就是我们写的程序，需要调C的栈的静态库

4、我们C++程序要用C实现的DS栈的静态库

  • 包含这个栈的头文件Stack.h
  • 在工程属性中配置静态库的目录和添加静态库

在这里插入图片描述在这里插入图片描述在这里插入图片描述

此时编译链接会报链接错误！
为什么？
解答：

我们现在是C++程序调用C的静态库，包的C的头文件，头文件只有函数的声明，链接时，要用函数名去找函数定义的地址，但是通过前面所学的函数重载我们知道，C++的函数名修饰规则和C语言不同，所以链接时，找不到函数定义的地址。

怎么解决：
这时，我们主角就要登场了
在这里插入图片描述
我们用extern "C"
就是告诉编译器，{}里面的函数是C编译器编译的，链接的时候，也用C的函数名规则去找函数定义的地址，这样就可以链接到了。

⭐相反，如果是C实现的程序去调C++的静态库该怎么办呢？
我们的目的就是让他们链接的时候，用同样的函数名修饰规则
如果我们在C++的静态库的头文件使用extern “C” 如图
在这里插入图片描述C程序要包C++静态库的头文件
这里就有问题了
：C不认识extern "C"
怎么办？
我们需要使用一下条件编译
_cplusplus只在C++中被定义所以这里条件编译后，在C++的静态库中extern "C"会被展开，告诉编译器{}里面用C的函数名修饰规则去处理。
而在C程序中这段头文件中的函数声明没有展开extern “C”
这样一来就解决了
在这里插入图片描述

引用

引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如你有一个大名，你也有一个小名，同学们还给你起了个外号，叫哪个名字都是你。

类型& 引用变量名(对象名) = 引用实体；

void Test()
{
int a = 10;
int& ra = a;//  定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}

我们打印出来地址是一样的，说明它们共用一块空间
注意：引用类型必须和引用实体是同种类型的

引用特性

  1. 引用在定义时必须初始化
  2. 一个变量可以有多个引用
  3. 引用一旦引用一个实体，再不能引用其他实体
void Test()
{
int a = 10;
// int& ra; // 该条语句编译时会出错 引用在定义时必须初始化
int& ra = a;
int& rra = a;//一个变量可以有多个引用
printf("%p %p %p\n", &a, &ra, &rra);//地址相同
int& ra=b;//错误   引用一旦引用一个实体，再不能引用其他实体
int d=30;
rra=d;//这里是把d赋值给b，此时a,ra,rra指向内容都变成30了
}

常引用

void TestConstRef()
{
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;
}

const int a=10;
int& b=a;//权限放大 不可以

const int a=10;
const int&b=a;//权限不变 可以

int a=10;
const int&b=a;//权限缩小 可以


double a=3.14;
int b=a;//类型转换，产生临时变量
const int&c=a; //引用的是临时变量，临时变量具有常性，所以要加const

使用场景

1、做参数

void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}

2、 做返回值

int& Count()
{
static int n = 0；//因为是static的所以出了作用域依然存在
n++;
// ...
return n;
}

首先注意一点：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

我们来看一段代码，看看此代码有什么问题，结果是多少？为什么？

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

输出结果是：7
解答：在这里插入图片描述当前代码问题：
1、存在非法访问，因为Add(1,2)的返回值是C的引用，但是出了Add函数作用域，函数栈帧就会销毁，此时C这块地方已经不属于自己了，可以被其他人覆盖了，此时我们访问C的位置就是非法访问了。
2、如果Add函数栈帧销毁，会清理空间的话，那我们取C位置的东西拿到的是随机值，ret就是随机值，这取决于编译器的实现

这里为什么是7不是3，就很简单了，之前C位置是3，但是后来又Add(3,4)，此时，C被7覆盖了，那我们ret是C的引用，当然取到的是7喽。

传值、传引用效率比较

首先，传值和值返回

我们以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低，比如很大的结构体。

而传引用和引用返回则没有拷贝这回事，这样效率会提高很多
总结一下：

引用的作用主要体现在传参和传返回值，减少拷贝提高效率

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间

int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}

看一下汇编：
在这里插入图片描述汇编底层实现上是一样的。但是理解的时候要以语法层理解。

引用和指针的不同点：

  1. 引用必须在定义的时候初始化，而指针最好初始化，只不过不初始化不会报错。
  2. 引用在语法上是一个变量的别名，没有开空间，而指针是存储一个变量的地址，要开空间。
  3. 引用在初始化时引用一个实体后就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
  4. 没有NULL引用，但有NULL指针。
  5. 在sizeof中含义不同，引用的结果为引用类型的大小，但指针始终是地址空间所占字节数（32位是4字节64位是8字节）。
  6. 引用进行++或者–是引用实体的++或–而指针的++或–则是指针向后先前偏移一个类型大小。
  7. 有多级指针，但没有多级引用。
  8. 访问实体方式不同，指针需要解引用，而引用编译器会自己处理。
  9. 引用比指针使用起来更安全。指针使用较为复杂也更容易出错，使用指针需要考虑空指针和野指针等问题，指针太灵活，所以相对而言没有引用安全。
  10. 10.引用表面好像是传值，本质也是传地址，只是这个工作由编译器完成。指针是间接操作对象，程序中使用指针可读性不好，而引用是对象的别名，对引用对象的操作就是对目标变量的操作。

内联函数

概念：

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

正常情况下，汇编下看函数调用要执行call命令

在这里插入图片描述如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

  1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
    但是release调试看不到，优化太多
  2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化
    在这里插入图片描述在这里插入图片描述
    我们看到现在就没有call命令了。

我们来说说为什么会存在内联函数
：调用函数需要建立栈帧，栈帧中要保存一些寄存器，结束后又要恢复，这些如果函数调用很多次，是有时间和空间上的消耗的，特别是短小的函数，函数创建和销毁栈帧所花费的时间比你这个函数的小算法还多，频繁的调用函数效率很垃圾，那咋办？
首先我们想到了宏，但是宏使用起来容易出错，所以有了内联函数！

内联函数的特性

  1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏的优缺点？

优点：

  1. 增强代码复用性
  2. 使用带参的宏定义完成函数的调用功能，避免压栈出栈的开销，提高性能
  3. 还可以完成编译器无法实现的功能，比如##连接符

缺点：

  1. 不方便调试（因为在预编译阶段就进行了替换）
  2. 没有类型检查，不够安全
  3. 如果带有（）会有边缘效应运算符优先级问题，易出错
  4. 因为是直接的文本替换，有时候会使代码可读性差，可维护性差，容易误用
  5. 因为是直接嵌入到代码中，如果宏较长，多次插入到代码会导致代码很冗余

C++有哪些技术替代宏？

  1. 常量定义使用const
  2. 函数定义换用内联函数

auto关键字(C++11)

auto简介

在C语言中我们使用的auto的意思是：使用auto修饰的变量，是具有自动存储器的局部变量。
但是没啥用，因为我们平时不会用到，相当于脱裤子放屁。

C++11中，标准委员会赋予了auto全新的含义即：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定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

auto的使用细则

  1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
return 0;
}
  1. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

auto不能推导的场景

  1. auto不能作为函数的参数
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
  1. auto不能直接用来声明数组
void TestAuto()
{
int a[] = {1,2,3};
auto b[] = {4，5，6};
}
  1. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
  2. auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

基于范围的for循环(C++11)

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		array[i] *= 2;
	}
	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
	{
		cout << *p << endl;
	}
}

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

使用如下：

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array)
	{
		e ++;    //因为你想影响数组里的元素，就应该用引用
	}
	for (auto e : array)
	{
		cout << e << " ";
	}
}

语法含义：
自动依次取array数组里的每一个元素赋值给e，然后自动判断结束。

范围for的使用条件

  1. for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

下面代码就存在问题，因为我们之前学过，数组传参之后会降维，而array必须是数组

void TestFor(int array[])
{
for(auto& e : array)
cout<< e <<endl;
}
  1. 迭代的对象要实现++和==的操作

指针空值nullptr(C++11)

C++98中：

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void Test()
{
int* p1 = NULL;
int* p2 = 0;
}

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，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。

所以nullptr就比较严谨
注意：

  1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
  2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
  3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

⭐感谢阅读，我们下期再见
如有错 欢迎提出一起交流

周周汪
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
C++入门基础知识
m0_37956168的博客
06-19 342
1. 命名空间 作用： 实际上就是一个由程序设计者命名的内存区域，程序设计者可以根据需要指定一些有名字的空间域，把一些全局实体分别放在各个命名空间中，从而与其他全局实体分隔开来。 访问方法：用 作用域解析符：: 来访问，AA : : x,AA表示空间域，x表示成员（名字）。 namespace AA1//AA1域（空间） { int a = 1;//成员 }
Accelerated C++源代码
08-16
透彻阐释了使用标准库（并且用标准库编写了各种抽象程序）的基础知识之后，我们才进入下一步，学习用C++的其他高级特征，来编写自己的抽象。第一和第二部分讨论语言的基础知识和标准库设施。其重点在于学会如何编写...
c++入门基础知识
zjx624bjh的博客
10-11 846
命名空间 C++基本的输入输出流 重载 C++缺省参数 指针和引用
编程入门基础知识总结.doc
10-07
编程入门的基础知识是每个程序员都必须掌握的基石。在编程世界里，程序的本质可以被概括为"算法 + 数据结构"。算法是解决问题的步骤描述，它定义了如何处理输入并产生输出；数据结构则是对数据的组织方式，它决定了...
C++面向对象课件
11-26
面向对象程序设计基础入门，其中对C++进行了简单的阐述，对其中重要的知识点进行了概括，以及和C程序设计的不同点
Accelerated C++ PDF 中英文版
08-16
透彻阐释了使用标准库（并且用标准库编写了各种抽象程序）的基础知识之后，我们才进入下一步，学习用C++的其他高级特征，来编写自己的抽象。第一和第二部分讨论语言的基础知识和标准库设施。其重点在于学会如何编写...
C++基础入门教程：基础知识大杂烩
weixin_45446903的博客
07-31 717
前言： 这篇文章主要介绍了C++基础入门教程：基础知识大杂烩,本文讲解了注释、头文件、命名空间等内容,需要的朋友可以参考下； 注意： 本系列教程不适合无任何编程语言基础的朋友，只是作为C++基础的一种补充。 教程内容基于《C++ Primer Plus》一书，适合初学者，熟手请直接忽略。 ​​​​​​​1.如果你不注释，那么，我会把你注释掉~！ C++的注释有2种， 第一种，单行注释...
C++基础知识快速入门
weixin_46416904的博客
04-23 8719
C++基础知识，快速入门 C++简介 C++是一种静态类型、编译式的、大小写敏感的、支持过程化编程、面向对象编程和泛型编程。 C++被认为是一种中级语言，它综合了高级语言和低级语言的特点。 C++完全支持面向对象程序化设计，包括面向对象开发的四大特征：封装、抽象、继承、多态 对象 - 对象具有状态和行为。例如：一只狗的状态-颜色、名称、品种，行为-摇动、叫唤、吃。对象是类的实例。 类 - 类可以定...
C++基础入门知识（一）
weixin_46969363的博客
11-09 253
1 C++初识 1.1 第一个C++程序 #include<iostream> using namespace std; int main() { cout << "Hello world" << endl; system("pause"); return 0; } 1.2 注释 作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码 两种格式 单行注释：// 描述信息 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明 多行
C++——基础知识入门
ljinshuo的博客
10-31 8738
1.初识C++ 1.1第一个C++程序 创建新项目，选择创建C++的空项目： 选择项目名称与位置： 在源文件中添加C++文件： # include <iostream> using namespace std; int main() { cout << "hello world" << endl; system("pause"); return 0; } 1.2注释 # include <iostream> using namespac
c++ 基础知识入门
Fly_bit的博客
06-19 367
一、命名空间 命名空间（namespace）是一种描述逻辑分组的机制，可以将按某些标准在逻辑上属于同一个集团的声明放在同一个命名空间中。 原来C++标识符的作用域分成三级：代码块（{……}，如复合语句和函数体）、类和全局。现在，在其中的类和全局之间，标准C++又添加了命名空间这一个作用域级别。 命名空间可以是全局的，也可以位于另一个命名空间之中，但是不能位于类和代码块中。所以，
【C++】C++入门基础知识
m0_62714628的博客
01-18 147
【C++】C++入门基础知识
c++基础知识入门
chupeiha4421的博客
08-08 62
c++类型划分 可以粗略的说c++就是在c的基础上增加了class类 c++将类型分为两种，一种是内置类型，一种是自定义类型 内置类型：也就是上图所分类的基本数据类型，即语言内部已定义的基本类型 自定义类型：自己用struct/class/union/enum等定义的类型 ...
C++——入门基础知识
最新发布
weixin_59913110的博客
04-26 771
在上面的例子中，中有一函数rand，而我们并不知道其中有这个函数，而是直接定义了一个名为rand的整形变量，此时就会造成重定义。这就是一种命名冲突的表现。那么在C++中，为了弥补这方面的不足，诞生出了命名空间这么一个东西。先简单看看命名空间是如何定义的：定义命名空间，需要用到namespace关键字，在其之后要跟上命名空间的名字(随便取)，然后再接一对大括号({})，大括号中可以定义命名空间的成员。namespace ly// 在全局域定义一个命名空间。
C++基础知识汇总——入门
xiaomu的博客
05-25 684
C++基础——入门（一） 目录： 输入/输出语句 命名空间 缺省参数 函数重载（核心概念之一） 引用 内联函数 auto关键字（C++11） 基于范围的for循环(C++11) 指针空值nullptr(C++11) （一）输入/输出语句 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。 使用C++输入输出更方便，不需增加数据格式控制，比如：整形–%d，字符–%c。 #include<iostream>//
c++入门——基础知识点（1）
紫阳战君的博客
08-01 133
1、命名空间 在c/c++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称都将存于全局作用域中，可能会导致许多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染namespace关键字的出现就是针对这种问题的。 （1）命名空间的定义 定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。 // 1、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

周周汪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值