C++基础入门

已于 2023-07-27 13:33:24 修改
阅读量2.5k 收藏 60
点赞数 37
分类专栏： C++学习 文章标签： c++ c语言 算法
于 2023-04-20 19:18:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67401157/article/details/130137204
版权

文章目录


前言：

C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。熟悉C语言之后，对C++学习有一定的帮助，本章节主要目标：

  1. 补充C语言语法的不足，以及C++是如何对C语言设计不合理的地方进行优化的，比如：作用域方面、IO方面、函数方面、指针方面、宏方面等。
  2. 为后续类和对象学习打基础。

一.C++关键字

C++总计63个关键字，C语言32个关键字。
(下面只是看一下C++有多少关键字，不对关键字进行具体的讲解。等后续章节学到以后再细讲。)
在这里插入图片描述

二.命名空间

1.引例

先看下面一段代码：

#include <stdio.h>
#include <stdlib.h>
 
int rand = 10;
 
int main()
{
    printf("%d\n", rand);
    return 0;
}

运行结果：
在这里插入图片描述
rand是一个库函数，我们再定义变量rand就会与其发生冲突。

以后工作时，我们面对海量的代码，势必会有各种各样相同的变量名字或函数名造成命名冲突，为了弥补这种语法的不足，C++引出了命名空间：即是对标识符的名称进行本地化，以避免命名冲突或名字污染。

2.命名空间定义

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员（类似结构体）：

//该命名空间的名字为dx(殿下p）
namespace dx
{
    //定义自己的变量/函数/类型等
	int rand = 10;
 	
 	//函数
	void qsort(int* a, int n)
	{
		//...
	}
 	//类型
	struct Node
	{
		int val;
		struct Node* next;
		//...
	};
}

命名空间可以嵌套：

namespace dx
{
	int rand = 10;
 
	namespace dx2
	{
        int rand = 20;
        
		namespace dx3
		{
			//....
		}
	}
}

同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中。

//test.cpp中定义
namespace dx
{
	int rand = 10;
 
	void qsort(int* a, int n)
	{
		//...
	}
 
	struct Node
	{
		int val;
		struct Node* next;
		//...
	};
}
//test.h中定义
namespace dx
{
	int sum = 0;
 
	int add(int a, int b)
	{
		//...
	}
}
 
//两个dx会被合并成为一个

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

3.命名空间的使用

定义了命名空间，那怎么使用命名空间中的内容呢？
比如：

namespace dx
{
 	// 命名空间中可以定义变量/函数/类型
 	int a = 0;
 	int b = 1;
 	int Add(int left, int right)
 	{
		return left + right;
	}
 	struct Node
 	{
 		struct Node* next;
 		int val;
 	};
}
int main()
{
	printf("%d\n", a);
	return 0;
}

运行结果：
在这里插入图片描述
无法直接使用。下面介绍3种命名空间的使用方式：

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

4.注意事项

在日常学习的时候，我们经常会见到这样的语句：

using namespace std;

这句话的含义是什么呢？

首先要知道，标准命名空间std是C++标准库中的命名空间，包含了很多常用的函数和对象，字符串，数学运算等，那么using namespace std就是引入了标准命名空间。

引入标准命名空间会使代码更简洁易读，但如果我们定义跟库重名的类型/对象/函数，就存在冲突问题。因此在开发大型项目时，我们一般使用：

  1. 作用域限定符访问
//作用域限定符访问
#include <iostream>
 
int main()
{
	std::cout << "hello world" << std::endl;
	return 0;
}
  1. 常使用的进行展开
using std::cout;
using std::endl;
 
int main()
{
	cout << "hello world" << endl;
	return 0;

但是在日常学习练习的时候，使用using namespace std会方便很多。

三.缺省参数

1.缺省参数的定义

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

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

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

2.缺省参数的分类

（1）全缺省参数

传参时，必须从左往右依次给

void F(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << endl;
}
 
int main()
{
	F(100);
	F(100, 200);
	F(100, 200,300);
	
	//错误示例：
	//F(100, ,300);
	return 0;
}

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

（2）半缺省参数

void F(int a , int b , int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << endl;
}
 
int main()
{
	F(100,200);
	F(100, 200, 300);
 
	return 0;
}

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

3.注意事项

  1. 半缺省参数必须从右向左给，不能间隔给
  2. 缺省参数不能在函数声明和定义中同时出现，只能出现在函数声明中
  3. 缺省值必须是常量或者全局变量
  4. C语言不支持（编译器不支持）

四.函数重载

1.函数重载的概念

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

//1.参数类型不同
int Add(int a, int b)
{
	return a + b;
}
double Add(double a, double b)
{
	return a + b;
}
 
//2.参数个数不同
int Add(int a, int b)
{
	return a + b;
}
int Add(int a, int b, int c)
{
	return a + b + c;
}
 
//3.参数类型的顺序不同
 
void F(int a, char b)
{
	//...
}
void F(char a, int b)
{
	//...
}
 
int main()
{
	Add(10, 20);
	Add(10, 20, 30);
	Add(2.2, 3.3);
	F(10, 'a');
	F('a', 10);
 
	return 0;
}

注意：函数重载与函数的返回值无关

2.C++为什么支持函数重载？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。当我们用函数重载定义了两个同名的函数Add，很显然我们自己知道传什么参数该调用哪个函数，但在编译器链接时，面对Add函数，链接器会使用哪个名字去找对应的栈帧呢？

int Add(int a, int b)
{
	return a + b;
}
 
void func(int a, double b, int* p)
{
}
 
int main()
{
	Add(1, 2);
	func(1,2,0);
 
	return 0;
}

其实编译器在编译与汇编阶段，会对函数名做修饰。不同的编译器对函数名的修饰也不同，为了方便观察，这里以Linux环境下的g++编译器为例。输入指令查看可执行程序反汇编的代码：

g++ Test.cpp -o Testcpp
objdump -S Testcpp

以下是Linux下g++修饰的汇编代码：
在这里插入图片描述

函数名修饰后变成 _Z+函数长度+函数名+类型首字母
为了作对比，我们再看看没有函数重载的C语言是否会对函数名做修饰：

gcc Test.c -o Testc
objdump -S Testc

在这里插入图片描述

在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变，这样就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

五.引用

1.引用的概念

引用：引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李火旺和火子哥是同一个人
格式： 类型& 引用变量名(对象名) = 引用实体

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

运行结果：

在这里插入图片描述

注意：引用类型必须和引用实体是同种类型的。
下面来比较一下引用与变量的地址是否相同：

//比较二者的地址
cout << &a << endl;
cout << &ra << endl;

运行结果：

在这里插入图片描述

可以看出引用变量与原变量用的是同一块地址空间。

2.引用的性质

  1. 引用在定义时必须初始化
int a = 0;
int& ra = a; 
//int& ra;    //错误的写法
  1. 一个变量可以有多个引用
int a = 0;
int& b = a;
int& c = a;
//...
// 三个变量都是a
  1. 引用一旦引用一个实体，再不能引用其他实体
int a = 0;
int b = 0;
 
int& ra = a;
ra = b;   // 不能再引用其他变量
// 对比指针
int* pa = &a;
pa = &b;
  1. 引用变量的类型与引用实体的类型要相同
int a = 0;
int& ra = a;
 
char ch = 'a';
char& rch = ch;

3.常引用

正常的变量是可以随意修改的：
（以int型举例）

 // 两者都是可读可写型
 int a = 10;
 int & b = a;

如果在变量前加const，那变量就只读，没有修改的权限，具有常量性。引用被const修饰的变量，不可以赋予该引用修改变量的权限，也就是不可以权限扩大：

// 只读型(const)
const int a = 20;
 
// 引用b是可读可写型  报错！（扩大了权限）
int& b= a;      × × ×
 
// 权限平移：都是只读型
const int& c = a;   √ √ √

但是引用一个无修饰的变量，可以赋予该引用只读的权限，也就是可以权限缩小：

//可读可写型
int e = 30;
 
//只读型
const int &f = e;

注意：当两个不同类型的变量比较大小或者类型转换的时候，并不会改变变量的类型，而是会在中间过程产生一个临时变量，临时变量具有常量性：

int ii = 1;

// 报错：引用rdd是变量ii的别名，但是rdd是double型，ii是int型，因此ii要先发生类型转换，
// 但转换的并不是ii本身，而是产生一个临时变量，该临时变量是double型，且具有常量性，
// 所以直接引用ii权限就被扩大了
double &rdd = ii;      
// 正确：权限平移
const double &rdd = ii;

在这里插入图片描述

4.使用场景

（1）引用做参数

根据引用的特性 ，会直接改变外部实参的值：

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

运行结果：

在这里插入图片描述

（2）引用做返回值

先看下面的代码：

int& Count(int x)
{
    int n = x;
    n++;
    return n;
}

int main()
{
    int& ret = Count(10);
    cout << ret << endl;
    printf("SSSSSSSSS\n");
    cout << ret << endl;

    return 0;
}

运行结果：

在这里插入图片描述

出现随机值了，这是为什么呢？

这其实涉及到函数栈帧的开辟与销毁，详细知识点请点击此处，在本文我简单介绍一下：

  1. 函数运行时，系统需要给函数开辟独立的栈空间，用来保存该函数的形参，局部变量以及一些寄存器的信息，也就是函数栈帧的开辟。
  2. 函数运行结束后，该函数对应的栈帧就被系统回收了，就是函数栈帧的销毁
  3. 空间被回收指这块栈空间暂时不能使用，但是内存还在，保存的数据还在。举个例子：放学后，教室需要锁门，使用权限就还给了学校，但是教室本身还在，教室里仍存放着书本文具等。
  • 据此，我们再分析上述代码，调用Count函数后，n 的别名返回后给 ret 接受，ret 引用的是一块被回收的空间，此时这块空间存的仍是n的值11，然后用printf函数打印一行字符串，又一次栈帧创建与销毁后，覆盖了原来的内存空间，存放的n的值11也就成了随机值。

引用做返回值正确的使用姿势：

int& Count(int x)
{
    static int n = x;
    n++;
    return n;
}

int main()
{
    int& ret = Count(10);
    cout << ret << endl;
    printf("SSSSSSSSS\n");
    cout << ret << endl;

    return 0;
}

运行结果：

在这里插入图片描述

所以，引用作返回值时，如果函数返回时，出了函数作用域，但是返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

引用作函数返回值时，调用函数时可修改返回对象：

#define N 10

typedef struct Array {
	int a[N];
	int size = N;
}Array;
 
int& Test(Array& a, int i)
{
	assert(i < N);
 
	return a.a[i];
}
 
int main()
{
	Array a;
	for (int i = 0; i < N; i++)
	{
		Test(a, i) = i * 10;
	}
	for (int i = 0; i < N; i++)
	{
		cout << Test(a, i) << " ";
	}
	cout << endl;
 
	return 0;
}

运行结果：

在这里插入图片描述

5.引用的效率

（1）传值与传引用的效率比较

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

//一组测试代码
#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;
}

在这里插入图片描述

（2）值和引用作为返回值的性能比较

//一组测试代码
#include <time.h>
struct A 
{ 
	int a[10000]; 
};
 
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
	TestReturnByRefOrValue();
	return 0;
}

在这里插入图片描述

6.引用和指针的区别

引用与指针的用法及原理在我们使用者看来是不相同的（引用是给变量取别名，指针是指向变量的地址），但是其实引用的底层实现就是以指针的方式实现的。例如：

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个字节)
  6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  7. 有多级指针，但是没有多级引用
  8. 访问实体方式不同，指针需要解引用，引用编译器自己处理
  9. 引用比指针使用起来相对更安全

六.内联函数

1.概念

内联函数 inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，不会建立函数栈帧。类似于宏

//定义一个内联函数
inline int Add(int x, int y)
{
	return x + y;
}
 
int main()
{
	int a = 3, b = 5;
 
	int ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

非内联函数在调用时，会建立函数栈帧，内联函数则不会。下面我们就在调用两种不同的函数时，查看各自的汇编代码：

//非内联函数
int Add(int x, int y)
{
	return x + y;
}
 
int main()
{
	int a = 3, b = 5;
 
	int ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

在这里插入图片描述
如上图所示，该指令就是调用函数的指令，调用函数必会建立函数栈帧。再来看看内联函数：

//内联函数
inline int Add(int x, int y)
{
	return x + y;
}
 
int main()
{
	int a = 3, b = 5;
 
	int ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

在这里插入图片描述
如图，此处并没有调用函数的过程，而是直接展开。

2.特性

内联函数并不总是最好的选择，它也是有利有弊：

  1. inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用。缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
  2. inline 对于编译器而言只是一个建议，不同编译器关于 inline 实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用 inline 修饰，否则编译器会忽略 inline 特性。
  3. inline 不建议声明和定义分离，分离会导致链接错误。因为 inline 被展开，就没有函数地址了，链接就会找不到。

回顾一下宏的优缺点：

优点：

  1. 增强代码的复用性。
  2. 提高性能。

缺点：

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

七.auto关键字(c++11)

1.什么是auto

C++中引入了新的关键字auto，其作用为自动推导类型：

int main()
{
	int a = 0;
	auto b = a;
	auto c = &a;

	//打印变量的类型
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;

	return 0;
}

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

2.auto使用细则

使用 auto 定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此 auto 并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将 auto 替换为变量实际的类型：

	//错误示例
	auto a;

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

	int a = 0;
	auto b = a;
	auto c = &a;
	auto& d = a;

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

	auto a = 1, b = 2;
	auto c = 3, d = 4.0;  // error: c和d的初始化表达式类型不同

auto 不能推导的场景:

  1. auto 不能作为函数的参数:
//错误示例
void Func(auto n)
{
	//...
}
  1. auto 不能直接用来声明数组；
	//错误示例
	auto arr[] = { 1,2,3 };
  1. 为了避免与 C++98 中的 auto 发生混淆，C++11 只保留了 auto 作为类型指示符的用法；
  2. auto 在实际中最常见的优势用法就是接下来会讲到的 C++11 提供的新式for循环，还有 lambda 表达式等进行配合使用

八.基于范围的for循环(c++11)

1.范围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 *= 2;
	for (auto e : array)
		cout << e << " ";
}

运行结果：

在这里插入图片描述

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

2.范围for循环的使用条件

  1. for 循环迭代的范围必须是确定的 ：
    对于数组而言，就是数组中第一个元素和最后一个元素的范围，对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
  2. 迭代的对象要实现++和==的操作
//错误示例
void TestFor(int array[])
{
	for (auto& e : array)
		cout << e << endl;
}

九.指针空值nullptr(c++11)

如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

	int* p = NULL;

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。
  • 为了避免出现类似的问题，C++11 中引进了新的关键字 nullptr ，为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。

本文到此结束，码文不易，还请多多支持哦！

殿下p
关注
  • 37
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 53
    评论
专栏目录
C++基础入门教程
张许平的博客
11-17 4万+
1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout <<
C++基础入门（超详细）
qq_44859533的博客
07-02 5万+
全网很全的C++基础入门，针对每一个概念以及概念之后的代码实现运行结果。可以帮助新手很快上手，也可以帮助老手回顾C++。
c++基础入门
yongzhouchen的博客
02-14 9890
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
C++基础入门1
怀秋秋意的博客
03-17 2198
详解c++基础入门知识，第一篇
c++ 基础入门
入门到放弃之路
03-11 9405
问题集合： 问题一：提示 无法启动程序，系统找不到指定文件 原因是 ：在源文件中的两个.cpp文件中都包含了main()函数，但一个项目中只能包含一个main()函数。 解决办法：移除掉不用的.cpp文件即可； 当需要某个文件时，再将其添加回来即可； 创建第一个程序 第一步：新建项目； 第二步： 第三步：在源文件右侧点击选择添加，新建项； 第四步：输入新建项的名称； 第五步：将以下代码写入； #include <i...
C++（c++基础入门，看这一篇就够了）
Xiaoming9106的博客
08-19 4万+
c plus plus 简称c++
C++编程基础入门
weixin_45911701的博客
10-18 5113
C++编程基础入门 1. 常量的定义方式 1.1 #define宏常量 ​ 语法：#define 常量名 常量值 ​ 通常在文件上方定义，表示一个常量 2.1 const修饰的变量 ​ **语法：**const 数据类型 常量名 = 常量值 ​ 通常在变量定义前加关键字const，修饰该变量为常量，不可修改 2. 标识符命名规则 ​ **作用：**C++规定给标识符（变量、常量）命名时，有一套自己的规则 ​ 1.标识符不能是关键字 ​ 2.标识符只能由字母、数字、下划
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
【黑马之C++基础入门讲义】
coollllgirl的博客
12-05 2362
C++基础入门
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++基础入门讲义.zip
01-15
C++基础入门讲义.md（带图片） 原地址在github，但是下载速度太慢了。 https://github.com/Gasuo/C-Resource
C++基础入门讲义md
07-16
非常详尽的C++入门讲义，很适合初学者
C的I/O操作
weidl001的博客
06-17 740
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 553
LeetCode 算法：排序链表 c++
线程简介及其函数使用实例（gcc *.c -lpthread）
CSDN_DU666666的博客
06-20 373
线程概念、线程接口提供方式、线程创建使用到的函数、多线程创建实例 、多线程创建实例 、多线程执行顺序问题和多线程占用内存问题
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 346
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
PySide（PyQt）的特殊按钮（互锁、自锁、独占模式）
xulibo5828的博客
06-19 232
pyside6的特殊按钮（互锁、自锁、独占模式）
c++基础入门。md
01-23
c语言是一种广泛应用的计算机编程语言，是一种基础的编程语言之一。它的语法简洁、结构清晰，在计算机科学和软件开发领域有着广泛的应用。C语言具有高效、灵活、可移植等特点，非常适合进行系统和应用程序的开发。 C语言的基础知识包括数据类型、运算符、控制语句、函数等。学习C语言需要掌握基本的语法和语义规则，还需要了解如何使用变量、数组、指针等数据结构，以及如何进行输入输出、文件操作等基本操作。 Markdown（简称md）是一种轻量级标记语言，它可以通过简单、易读易写的文本格式，实现文本内容的排版和格式化。Markdown语法简单明了，学习成本低，适合用来书写文档、笔记、博客文章等。了解Markdown的基础知识，包括标题、列表、链接、图片、代码块等语法规则，可以帮助我们更高效地编写和编辑文本内容。 在学习C语言和Markdown的过程中，我们可以通过阅读相关教程和文档来学习基本知识，通过练习和实践来巩固和提升自己的技能，还可以参与开源项目或者编程社区，与他人交流和分享经验，从而不断提高自己的编程水平和文本编辑能力。总之，掌握C语言和Markdown的基础知识对于计算机编程和文本编辑都是非常重要的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

殿下p

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

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

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

打赏作者

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

抵扣说明：

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

余额充值