C++基础入门

已于 2023-06-22 10:53:49 修改
阅读量668 收藏 2
点赞数 2
分类专栏： C++（第一版） 文章标签： c++ 开发语言 算法
于 2023-06-21 17:24:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73168361/article/details/131330941
版权

0.前言

你好这里是limou3434的C++博文系列，对于C++，我计划出一个学习专栏，预计在8月份初步完成，这些都是我学习C++时的一些体会，能被您所任用真的是太好了。

感兴趣的话，您还可以看看我的其他博文系列。

本次我给您带来的内容主要是C++的一些基础知识，如果您学过一门语言（最好是C语言）学起来就会轻松一些。本文主要是指出一些和C语言编程中有比较大不同的地方。

  1. C++是在C语言的基础上，容纳进面向对象编程语言的思想，并且增加了许多有用的库，以及编程范式等
  2. 在学习C++语言后，可以明白C语言设计不合理的地方，明白面向对象编程是怎么一回事

1.C++关键字

C++比C语言多了很多关键字，具体可以到菜鸟教程粗略看一看了解一下。

2.命名空间

2.1.问题隐患

在C++中，变量和函数和类都是大量存在的，这些名字都会存储在全局作用域中，因此在使用的时候可能导致很多的冲突.

2.2.解决方案

  • 使用命名空间可以对标识符的名字进行本地化，避免造成命名冲突或名字污染，namespace就是针对这个问题的，而C语言没有办法解决这个问题（例如将库函数名字作为新定义的变量）
  • C++允许同一个工程存在多个同名称的命名空间，编译器最后会合并成同一个命名空间里
  • C++为了防止名字的冲突，便把标准库的东西都放入std这个命名空间。这样就可以使用标准库的名字来命名自己的变量和函数，因此要使用标准库的名字也需要写出它的命名空间

2.3.namespace的使用例子

namespace limou3434//后面是这块命名空间的名字
{
    int print = 100;//在命名空间内定义一个变量
    int function(int n)//在命名空间内定义一个函数
    {
        return n + 1;
    }
    struct Limou//在命名空间内定义一个结构体
    {
        int a;
        char b;
        float c;
        double d;
    };
    namespace limou//在命名空间内嵌套一个命名空间
    {
        int e = 1;
        int f = 2;
        int g = 3;
    }
}
int main()
{
    return 0;
}

2.4.使用命名空间的成员

2.4.1.使用作用域限定符“::”单独引用

//命名空间名称::命名空间内的成员名字;
#include <stdio.h>
namespace limou3434//后面是这块命名空间的名字
{
    int print = 100;//在命名空间内定义一个变量
}
int main()
{
    printf("%d\n", limou3434::print);
    return 0;
}

2.4.2.使用关键字using将命名空间的某个成员引入（项目经常使用）

//using 命名空间名称::命名空间内成员名字;
#include <stdio.h>
namespace limou3434//后面是这块命名空间的名字
{
    int print = 100;//在命名空间内定义一个变量
}
using limou3434::print;
int main()
{
    printf("%d\n", limou3434::print);
    return 0;
}

2.4.3.使用关键字using和namespace将命名空间的整体引入

这样写不太好，这样会把所有标准库的名字全部暴露

using namespace limou3434;
using namespace std;//这里说明cout是std这块命名空间的成员之一
int main()
{
    cout << print;
    return 0;
}

3.C++输入和输出

3.1.代码例子

#include<iostream>
using namespace std;
int main()
{
    int a = 0;
    cin >> a;
    cout << a << endl;
    return 0;
}

3.2.代码解说

  1. 使用cout和cin必须包含头文件
  2. 使用cout和cin必须指出其命名空间使用方法为std
  3. <<是流插入运算符，>>是流提取运算符（也有叫“输入输出符号”的）
  4. C++的输入输出可以自动识别变量的类型，无需再指定输入输出格式
  5. 这里的cout和cin分别是ostream和istream类型的对象，>>和<<也涉及到运算符重载的知识，还涉及到IO流的用法，不过这些都是后话
  6. 早期标准库将所有功能都在全局域中实现，声明在.h的头文件中，使用的时候include一下就行，后来将这些实现改到std命名空间下，为了和头文件区分并且正确使用命名空间，规定C++头文件不带.h
  7. 有的老旧编译器还支持#include<isstream.h>的形式，而后续的编译器大部分都不再支持
  8. 虽然是自动控制，但是cout和cin还有其他复杂用法，包括控制输出格式等等，但是这些对比后续学习内容不算重点，就先不在此描述（而且C++也依旧支持C的printf和scanf等库函数）
  9. 另外，std是C++标准库的命名空间，在日常练习中虽然可以直接将整个命名空间全部暴露，但是在大型工程中，一般都会使用作用域限定符，只暴露某一成员

4.缺省参数

4.1.缺省函数的使用

声明或定义函数的时候为函数指定一个缺省值（默认值，这里是翻译问题，才叫缺省）。如果在使用函数的时候没有指定实参，就使用默认值为函数参数，否者使用指定的实参

#include<iostream>
using namespace std;
void function(int a = 0)
{
    if (a == 0)
    {
        cout << "你好！！！" << endl;
    }
    else
    {
        cout << "hello!!!" << endl;
    }
}
int main()
{
    function();
    function();
    function(1);
    return 0;
}

4.2.“全缺省函数”和“半缺省函数”的使用

  • 可以只指定一部分参数有默认值，或者全部指定有默认值
  • 半缺省函数的参数必须“从右往左”给出，不可间隔给予默认值
  • 缺省函数不能在函数声明和定义里同时出现，要以声明为准
//.h文件 
voide function(int a = 100);

//.cpp文件 
void function(int a = 50) 
{
	//某些具体代码
}

//在VS2022中哪怕重定义的缺省的值是一样的也不行
#include <iostream>
using namespace std;
void fun(int a = 0);
int main()
{
	fun();
	return 0;
}
void fun(int a = 0)
{
	if (a == 0)
	{
		printf("0\n");
	}
	else
	{
		printf("%d\n", a);
	}
}
  • 另外C++没有允许使用“(,1)”这类的写法
  • 之前写的函数可以被缺省的做法优化，比如“栈的初始化函数”中，开辟空间只开了一点，但是我们明明知道要用的栈元素比较多，我们还是要从较少的几个元素开始，一点一点申请空间，这是有较大的消耗的，而缺省就可以优化这一点

5.函数重载

在现实生活中有的词语可以根据上下文语义，从而产生不同的意思，这就是一种重载的体现

5.1.函数重载

  • 在C++中允许在同一个“作用域”中声明几个类似功能的同名函数，这些函数的形参列表（形参个数、形参类型、形参顺序）是不同的，常常用来处理实现功能类似、数据不同的问题。而且也根据这个形参的使用来区分不同重载的函数
  • 需要注意的是：返回值的不同、形参名字的不同都不构成函数重载
  • 实际上cout、cin能够自动识别的本质也是函数重载，在库里面已经帮我们实现好了
#include<iostream>
using namespace std;
void function(int a = 0)
{
    if (a == 0)
    {
        cout << "你好！！！" << endl;
    }
    else
    {
        cout << "hello!!!" << endl;
    }
}
char function(char b)
{
    cout << b << endl;
    return 1;
}
int main()
{
    function();
    function(1);
    function('c');
    return 0;
}
  • 为什么重载在C语言不支持，而C++语言却支持？（以下现象只有在汇编代码中才能看出来）
    • 要明白这个过程最主要在于链接
      • 预处理：头文件展开、宏替换、条件编译、去掉注释
      • 编译：语法检查、生成汇编代码
      • 汇编：将汇编代码转化为二进制机器码，生成目标文件
      • 链接：将程序合起来，生成可执行程序（这个合起来的意思就是将只给声明的函数地址找到链接起来，如果找不到就是链接错误。而具体的找法就是为每个目标文件做一个符号表，通过符号表来寻找对应的地址）
    • 而在C语言就是在这个链接阶段时，查找符号表的时候，有两个同名函数符号且地址不同，这就发生了冲突。即：“C语言直接将函数名作为符号来对应函数地址”
    • 而C++语言在这个链接阶段时，函数符号是根据函数名和参数名来生成的，这样符号名字不一样，地址也不一样，就可以构成函数重载的用法。即：“C++语言将函数名和参数名等组合起来构成符号来对应函数地址，这也解释了为什么函数重载需要靠参数来标识不同的重载函数”
    • 因此综上所述，C语言不支持函数重载（没有函数修饰规则），C++语言支持函数重载（有函数修饰规则）
    • 另外，在C++这个符号表里的“函数修饰规则”在不同环境是有可能不一样的，但是一定是依赖函数参数来生成的
  • 引用在定义的时候就必须初始化
  • 一个变量可以有多个引用
  • 引用一旦引用一个实体，就再也不能引用其他实体
int a = 10;
int& b = a;

int x = 20;
b = x;//因此这个语句的意思是“x的值赋给b”，而不是“x成为了b的别名”，这跟指针就有很大的区别

5.2.重载原理

有关重载的原理这里，涉及到的C++内容比较多，以后我再来进行补充。

6.引用

6.1.引用概念

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

6.2.语法格式

类型& 引用变量名(对象名) = 引用实体;
  • “引用”是给变量取别名，“typedef”是给类型取别名
  • 还可以给引用后的别名取别名
  • 引用更多是在函数的参数处使用，尤其是大对象传参的时候会提高效率
  • 引用还可以在函数的返回值处使用，但是注意函数内部定义的变量一旦出函数作用域就会被销毁，此时不能使用引用返回，只能使用传值返回（但是如果这个局部变量被静态关键字static修饰，那就可以直接使用引用返回）
  • 引用的变量类型和引用类型不一样时，会发生权限放大错误，本质是创建了临时变量，而临时变量具有常属性

6.3.具体代码

6.3.1.例一

#include <stdio.h>
int main()
{
    int a = 10;//实际变量
    int& a1 = a;//引用1
    int& a2 = a;//引用2
    printf("%d %d %d\n", a, a1, a2);
    printf("%p %p %p", &a, &a1, &a2);
    return 0;
}

6.3.2.例二

int main()
{
    const int a = 10;
    //int& a1 = a;
    const int& a1 = a;
    10;
    //int& b1 = 10;
    const int& b1 = 10;
    double c = 3.14159;
    //int& c1 = c;
    const int& c1 = c;
    return 0;
}

6.3.3.例三

void Swap(int& a, int& b)
{
  	int tmp = a;
  	a = b;
  	b = tmp;
}
int main()
{
	int x = 0, y = 2;
  	Swap(x, y);
}

6.3.4.例四

#include <cstdio>
int& function(int& x)//int& x = i，因此x是i的别名
{
    x++;//这个x++等价于i++
    return x;//返回x，int& ("function()") = x，因此函数甚至可以被赋值
}
int main()
{
    int i = 0;
    int j = 0;
    j = function(i);
    printf("%d\n", j);
    printf("%d\n", function(i) = 10);
    return 0;
}

6.3.5.例五（很重要的一个例子）

//顺序表结构体
typedef struct SeqList
{
 	int* a;
	int size;
	int capacity;
}SL;
//初始顺序表
void SLPushInit(SL& s, int capacity = 4);
//尾插顺序表
void SLPushBack(SL& S, int x);
//修改顺序表
int& SLAt(SL& s, int pos);
{
	assert(pos >= 0 && pos <=s.size);
  	return s.a[pos];
}
int main()
{
	SL sl;
  	SLPushInit(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) << endl;//输出顺序表的元素
    }
  	SLAt(sl, 0)++;//拿到s.a[pos]，对其进行++
  	SLAt(sl, 0) = 10;//拿到s.a[pos]，修改成10
}

6.3.6.例六（权限）

#include <iostream>
using namespace std;
int main()
{
	const int c = 20;//c可读不可写
	//int& d = c;//d把c权限放大了（可读可写），这是不被允许的
  	const int& d = c;//这是允许的，属于权限平移的概念
  
  	int e = 30;
  	const int& f = e;//但是权限缩小是被允许的
  
  	int g = 1;
  	double h = g;//这里产生一个临时变量，将存储数据提升后的g，再赋予h（这里g用显式强转也不行，无论是显式还是隐式，都不会改变g本身的类型）
  	//double& i = g;//这是不被允许的，因为这里产生一个临时变量，将存储数据提升后的g，而这个临时变量具有常属性，临时变量被h引用的话发生了权限放大
  	const double& i = g;//这是被允许的，只是发生了权限平移
  
 	const double& j = 3.14;//这个也是被允许的，因此拥有const修饰的引用允许引用常量。所以如果是在函数形参处使用引用时，如果不需要改变值，就要尽可能使用const修饰
  	return O;
}
  • 注意权限放大和缩小只适用在指针和引用上，普通变量之间的赋值是没有作权限要求的，因为这只是做一份临时拷贝
#include <iostream>
using namespace std;
void function_1(int n)
{
	;
}
void function_2(int& n)
{
	;
}
void function_3(const int& n) 
{ 
	;
}
int main()
{
	int a = 10;
	const int b = 20;

	function_1(a);
	function_1(b);
	function_1(30);

	function_2(a);
	//function_2(b);//这是不被允许的
	//function_2(30);//这是不被允许的

	function_3(a);
	function_3(b);
	function_3(30);

	return 0;
}

6.4.指针和引用的区别（两者是十分相似的）

指针更强大、更危险、更复杂/引用局限一些、更安全、更简单

  1. 概念：引用在概念上定义一个变量的别名，指针存储一个变量地址。
  2. 内存： 引用没有开空间，但是指针开了4个字节或是8个字节的空间
  3. 初始化：引用在定义时必须初始化，指针没有要求
  4. 重新赋值：引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
  5. 空问题：没有NULL引用，但有NULL指针
  6. sizeof：在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
  7. 算术运算：引用自加，即引用的实体增加1；指针自加，即指针向后偏移一个类型的大小
  8. 嵌套使用：有多级指针，但是没有多级引用
  9. 访问实体方式：访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  10. 安全性：引用比指针使用起来相对更安全

6.5.传值和传引用的效率对比

这里可以查看汇编代码，基本没有区别

7.内联函数

7.1.内联概念

  1. 内联关键字是inline，被其修饰的函数就叫内联函数
  2. 编译的时候，只要满足条件，C++编译器会在调用内联函数地方直接展开，没有函数调用建立栈帧的开销，内联函数能提升程序运行的效率
  3. 内联关键字的使用很像宏的使用
  4. 在debug下默认是不展开的，这里打开反汇编就会发现依旧是调用函数，这是为了方便调试，这是可以通过设置规避（“配置属性”-“C/C++”-“常规”-“调试信息格式”-“程序数据库(/Zi)”并且修改“配置属性”-“C/C++”-“优化”-“内联函数拓展”-“只使适用于 __inline(/Obl)”）

7.2.具体代码

#include<iostream>
using namespace std;
inline int add(int a = 0, int b = 0)//被inline修饰的函数
{
    return a + b;
}
int main()
{
    int c = 0;
    c = add(3, 5);
    cout << c;
    return 0;
}

7.3.内联函数的反汇编（以后换Linux看）

这一部分在Windows不好演示，就等我后续用Linux再补充吧……

7.4.内联函数的特性

  • inline本质是一种空间换时间的做法，如果编译器将函数当成内联函数，在编译期间就会将函数体替换函数调用
    • 劣势：有可能使得目标文件变大
    • 优势：少了调用开销，提高程序的运行效率
  • inline类似C语言里的寄存器变量关键字，只是向编译器发出一个请求，不同编译器关于inline的实现机制可能不一样。
  • 一般建议在以下情况来使用inline：将函数规模小、非递归、非频繁调用的函数采用inline修饰，否则编译器有可能会忽略inline的特性（这是因为，函数内部代码指令如果比较长，有可能会让编译的程序暴增，导致编译产生的程序变大。这些更多取决于编译器对inline的实现和理解）
  • 另外被内联关键字修饰的函数，其声明和定义一般不建议分开写，分开会导致链接错误。因此最好是把内联函数的声明和定义直接一起写到头文件里，不要去做分离！

7.5.对比宏和inline

7.5.1.宏的优点

  1. 提高代码的复用性（让你的代码能适应更多种的情况，完成更多种情况的任务，这就是代码的复用性）代码的可维护性变强，修改某些常量值快捷方便
  2. 宏函数能提高效率，减少栈帧的建立

7.5.2.宏的缺点

  1. 不方便调试带有宏的代码（因为预编译阶段进行了替换，而调试是在编译后的）
  2. 导致代码的可读性差、有一点的复杂性，容易误用
  3. 没有类型安全的检查（替换机制），易出现类型错误

7.5.3.宏的代替方案

  1. 常量定义可以使用C++的const、enum
  2. 短小函数定义可以使用C++的内联关键字inline

7.6.约定

在现代C++中，基本建议尽量使用const、enum、inline，而不使用宏

8.“typedef关键字”和“auto关键字”

8.1.typedef关键字

随着一个工程的扩大，程序中用到的类型也越来越复杂，经常体现在

  • 类型难以拼写，容易拼错
  • 含义不明确，导致用错
/*没有使用tepedef重命名*/
#include <string>
#include <map>
int main()
{
    std::map<std::string,std::string>m{ { "apple", "苹果" }, { "orange", "橙子" },  {"pear", "梨"} };
    std::map<std::string, std::string>::iterator it = m.begin();
    //其中std::map<std::string,std::string>::iterator是一个类型，都是类型的名字太长了，容易写错，可以尝试使用typedef给这个类型取个别名
    while (it != m.end())
    {
        //....
    }
    return 0;
}

/*没有使用tepedef重命名*/
#include <string>
#include <map>
int main()
{
    std::map<std::string,std::string>m{ { "apple", "苹果" }, { "orange", "橙子" },  {"pear", "梨"} };
    std::map<std::string, std::string>::iterator it = m.begin();
    //其中std::map<std::string,std::string>::iterator是一个类型，都是类型的名字太长了，容易写错，可以尝试使用typedef给这个类型取个别名
    while (it != m.end())
    {
        //....
    }
    return 0;
}
  • 在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候就要清楚知道表达式的类型。然而要做到这点并非那么容易，因此C++11给auto一个新的定义

8.2.auto关键字（C++11）

  • 在C++11的标准中，auto不再是存储类型说明符，而是一个新的类型指示符，来指示编译器
  • auto声明的变量必须由编译器在编译时期推导而得
  • 使用auto定义变量时必须对其进行初始化，在编译阶段编译器会根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
#include <iostream>
using namespace std;
int function()
{
    return 10;
}
int main()
{
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = function();
    cout << typeid(b).name() << " " << b << endl;
    cout << typeid(c).name() << " " << c << endl;
    cout << typeid(d).name() << " " << d << endl;
    //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    return 0;
}
  • 结合指针和引用来使用
    • 结合指针的话，auto和auto*是没有区别的
    • 结合引用的话，auto和auto&是有区别的，必须要加&
#include <iostream>
using namespace std;
int main()
{
    //一个变量
    int x = 100;

    //结合指针
    auto a = &x;
    auto* b = &x;

    //结合引用
    auto& c = x;

    //测试类型和输出，typeid可以打印类型
    cout << typeid(a).name() << " " << a << endl;
    cout << typeid(b).name() << " " << b << endl;
    cout << typeid(c).name() << " " << c << endl;

    //修改变量
    *a = 10;
    *b = 20;
    c = 30;
    return 0;
}
  • 在同一行定义多个变量
    • 当在同一行使用auto来声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量
#include <iostream>
using namespace std;
int main()
{
    //正确使用
    auto a = 1, b = 2;

    //错误使用
    auto c = 3, d = 4.0;//该行代码会编译失败，因为c和d的初始化表达式类型不同
    return 0;
}
  • 结合基于范围的for循环中使用auto
  • auto不能推导的场景
    • auto不能作为函数的形参，因为函数编译是要建立栈帧的，这个时候都不知道形参的大小，怎么知道从哪里开始创建栈帧呢？
    • auto不能用来声明数组
  • 为了避免和C++98的auto发生混淆，C++11只保留了auto作为类型指示符的用法
  • auto的最大的优势
    • 其实在C++11提供的新式for循环以及lambda表达式

9.基于范围的for循环

这不是C++的首创，而是后面加进来的

9.1.范围for的语法

//在C++98中，遍历一个数组可以按照以下的方式使用
#include <iostream>
using namespace std;
//使用C++98遍历方式
int main()
{
    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后面的括号由冒号“：”分为两部分，第一部分是范围内用于迭代的变量，第二部分表示被迭代的范围
#include <iostream>
using namespace std;
//使用C++11遍历方式
int main()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
        e *= 2;
    for(auto e : array)
        cout << e << " ";
    return 0;
}

9.2.范围for的使用条件

由于C++不支持直接传数组（这样消耗大，浪费）所以在函数传数组的时候必须提供begin和end方法，begin和end就是for循环迭代的范围（有关begin和end的具体使用后面再说）

void function(int arr[])//这个函数是不正确的，因为for的范围不确定
{
	for(auto& e : arr)
    	cout << e << endl;
}

10.指针空值nullptr（C++11）

10.1.NULL的概念

//NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
//在C++98中，字面量0既可以是一个整型数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看作整型常量，如果这么使用NULL时，就会具有一定的麻烦
void f(int)
{
    cout<<"f(int)"<<endl;
}
void f(int*)//函数重载
{
    cout<<"f(int*)"<<endl;
}
int main()
{
    f(0);
    f(NULL);//误用第一个函数，因为处理NULL的时候，NULL是被定义为0的
    f((int*)NULL);//需要使用强制类型转换才可以使用第二个函数
    return 0;
}

10.2.nullptr的概念

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

11.打印数据类型

在C++中，可以使用函数来打印一个变量的类型

#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	double b = 3.14;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	return 0;
}

这个了解一下就行，以后我还会在带您仔细研究这个打印数据类型的原理的。

limou3434
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础入门（超详细）
2301_76575356的博客
05-28 1万+
c++
【C++初阶】一、C++入门基础（详细总结）
Clumsy、笨拙的博客
03-01 1万+
C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字(随自己定义)，然后接一对{}即可，{}中即为命名空间的成员。注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。
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++入门基础（干货总结，建议收藏！）
m0_73231946的博客
09-23 1321
c++是一门更多是面向对象程序化设计的语言，因此我们在学习过程中要转变自己的思想，很多人在学习这门语言时，还会和以前C语言面向过程的思想来思考问题，那么带来的结果就是学起来非常困难。所以说学好c++，转变面向对象的思想很重要！
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++基础入门讲义.zip
01-15
**C++基础入门讲义** C++是一种强大的、通用的编程语言，被广泛应用于系统软件、游戏开发、应用软件、嵌入式系统等各个领域。它由Bjarne Stroustrup于1979年在贝尔实验室开发，是C语言的增强版，增加了面向对象编程...
C++基础入门讲义md
07-16
非常详尽的C++入门讲义，很适合初学者
C++基础入门学习笔记
weixin_43544679的博客
08-12 6900
C++基础入门 1.1 hello world #include<iostream> using namespace std; int main() { cout << "Hello world" << endl; system("pause"); return 0; } 1.2 注释 作用：在代码中加一些说明和解释，方便自己或其他程序员程序员阅读代码 两种格式 单行注释：// 描述信息 通常放在一行代码的上方，或者一条语句的末尾，对该行代码说明
C++编程基础入门
weixin_45911701的博客
10-18 5185
C++编程基础入门 1. 常量的定义方式 1.1 #define宏常量 ​ 语法：#define 常量名 常量值 ​ 通常在文件上方定义，表示一个常量 2.1 const修饰的变量 ​ **语法：**const 数据类型 常量名 = 常量值 ​ 通常在变量定义前加关键字const，修饰该变量为常量，不可修改 2. 标识符命名规则 ​ **作用：**C++规定给标识符（变量、常量）命名时，有一套自己的规则 ​ 1.标识符不能是关键字 ​ 2.标识符只能由字母、数字、下划
C++（c++基础入门，看这一篇就够了）
热门推荐
Xiaoming9106的博客
08-19 4万+
c plus plus 简称c++
c++入门基础（基础语法）
weixin_46836127的博客
11-25 2921
一个变量相当于输出一个点，一个循环相当于输出一条线，双重循环相当于输出一个平面，三重循环相当于输出一个立体图形。总结：与if语句比，对于多条件判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间。表达式3){ // 表达式2为真继续循环，否则结束循环。4 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上。while( 循环条件 ){ // 条件为真继续循环，否则结束循环。
c++入门(基础)
fw5884179的博客
09-23 2386
c++入门基础知识
C++入门基础学习
最新发布
yun2739_love的博客
05-12 1104
C语言是结构化和模块化的语言，适合处理较小规模的程序，对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，在20世纪80年代，计算机界提出OOP（object oriented programming：面向对象）思想，支持面向对象的程序设计语言就此诞生。1982年，Bjarne Stroustrup 博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础入门：从零开始学习关键点
"C++基础入门教程概览" 在C++基础入门的学习中，本资源涵盖了C++语言的核心概念和基础知识，旨在帮助零基础读者快速上手。以下是详细的知识点讲解： 1. **C++程序的四个步骤**： - 创建项目：使用Visual Studio...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

limou3434

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

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

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

打赏作者

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

抵扣说明：

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

余额充值