C++基础学习二

已于 2022-10-25 19:45:54 修改
阅读量742 收藏
点赞数
分类专栏： C/C++ 文章标签： 1024程序员节 c++
于 2022-10-24 15:54:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51002159/article/details/127494346
版权

文章目录

C++基础学习二

数组

int main()
{
    //数据类型 数组名[数组长度]
    int arr[5];int i;
    arr[0]=10; arr[1]=20; arr[2]=30; arr[3]=40; arr[4]=50;
    cout<<arr[0]<<' '<<arr[1]<<' '<<arr[2]<<' '<<arr[3]<<' '<<arr[4]<<endl;
    //数据类型 数组名[数组长度]={值1，值2....}
    int arr1[5]={10,20,30,40,50};
    for(int i=0;i<5;i++) {
        cout << arr1[i] << endl;  //如果初始化数据未全部赋值，会用0填补
    }
//    数据类型 数组名[]={值1，值2，值3.....}
     int arr2[]={60,70,80,90,100};
    for(int i=0;i<5;i++) {
        cout << arr2[i] <<' ';  //如果初始化数据未全部赋值，会用0填补
    }
    return 0;
}

统计数组在内存中所占空间

cout<<"arr2所占内存为:"<<sizeof(arr2)<<endl;
/*
arr2所占内存为:20
*/

查看数组首地址

cout<<"arr2数组的首地址为:"<<arr<<endl;
cout<<"arr2数组第一个元素的地址为:"<<&arr[0]<<endl;
cout<<"arr2数组第二个元素的地址为:"<<&arr[1]<<endl;
/*
arr2数组的首地址为:0x61fe00
arr2数组第一个元素的地址为:0x61fe00
arr2数组第二个元素的地址为:0x61fe04
*/

数组中找最大值

int main()
{
    int arr[5]={300,500,180,400,250};
    int max=arr[0];
    for(int i=1;i<5;i++)
    {
        if(arr[i]>max)
        {
            max=arr[i];
        }
    }
    cout<<"最大数为"<<max<<endl;
    return 0;
}
/*
最大数为500
*/

数组逆序

#include <iostream>
using namespace std;
int main()
{
    int arr[5]={1,2,3,4,5};
    int length=sizeof(arr)/sizeof(arr[0]),t;
    for(int i=0;i<length;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
    for(int i=0;i<length/2;i++)
    {
        t=arr[i];
        arr[i]=arr[length-i-1];
        arr[length-i-1]=t;
    }
    for(int i=0;i<length;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
    return 0;
}
/*
1 2 3 4 5
5 4 3 2 1
*/

冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

img

int main()
{
    int arr[]={3,6,1,0,5,9,7};
    int length=sizeof(arr)/sizeof(arr[0]),t;
    for(int i=0;i<length;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
    for(int i=0;i<length-1;i++){
        for(int j=0;j<length-1-i;j++)
        {
            if(arr[j]>arr[j+1]) {
                t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t;
            }
        }}
    cout<<"----排序后----"<<endl;
    for(int i=0;i<length;i++)
        cout<<arr[i]<<' ';
    cout<<endl;
}
/*
3 6 1 0 5 9 7
----排序后----
0 1 3 5 6 7 9
*/

二维数组

#include <iostream>
using namespace std;
int main()
{
    // 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
    int arr[2][3]={
            {1,2,3},
            {4,5,6}
    };
    cout<<"------1------"<<endl;
    for(int i=0;i<2;i++)
    {
        for(int j=0;j<3;j++)
        {
            cout<<arr[i][j]<<' ';
        }
        cout<<endl;
    }
    cout<<"------2------"<<endl;
    // 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
    int arr1[2][3]={7,8,9,10,11,12};
    for(int i=0;i<2;i++)
    {
        for(int j=0;j<3;j++)
        {
            cout<<arr1[i][j]<<' ';
        }
        cout<<endl;
    }
    cout<<"------3------"<<endl;
    //数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
    int arr2[][3]={1,2,3,7,8,9,10,11,12};
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            cout<<arr2[i][j]<<' ';
        }
        cout<<endl;
    }
    return 0;
}
/*
------1------
1 2 3
4 5 6
------2------
7 8 9
10 11 12
------3------
1 2 3
7 8 9
10 11 12
*/

二维数组名

  • 查看二维数组所占内存空间
  • 获取二维数组首地址

统计每一行数字之和

int main()
{
    int score[3][3]={
            {100,100,100},
            {90,50,100},
            {80,90,85}
    };
    int sum[3]={0,0,0};
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            sum[i]+=score[i][j];
        }
    }
    for(int i=0;i<3;i++)
        cout<<sum[i]<<' ';
    cout<<endl;
    return 0;
}
/*
300 240 255
*/

函数

概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。

函数的定义

函数的定义一般主要有5个步骤：

1、返回值类型

2、函数名

3、参数表列

4、函数体语句

5、return 表达式

返回值类型 函数名 （参数列表）
{
       函数体语句
       return 表达式
}

int add(int num1,int num2)
{
    return num1+num2;
}
int main()
{
    int a=3,b=4,sum;
    sum= add(a,b);
    cout<<sum<<endl;
    return 0;
}

值传递

  • 所谓值传递，就是函数调用时实参将数值传入给形参
  • 值传递时，如果形参发生改变，并不会影响实参
void swap(int num1, int num2)
{
	cout << "交换前：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
    // 10
    // 20
	int temp = num1;
	num1 = num2;
	num2 = temp;
	cout << "交换后：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
    // 20
    // 10
	//return ; 当函数声明void时候，不需要返回值，可以不写return
}

int main() {
	int a = 10;
	int b = 20;
	swap(a, b);
	cout << "main中的 a = " << a << endl;
	cout << "main中的 b = " << b << endl;
    // 10
    // 20
	system("pause");
	return 0;
}

总结： 值传递时，形参是修饰不了实参的

函数的常见样式

常见的函数样式有4种

  • 无参无返
  • 有参无返
  • 无参有返
  • 有参有返

函数的声明

作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

  • 函数的声明可以多次，但是函数的定义只能有一次
//声明
int max(int a, int b);
//定义
int max(int a, int b)
{
	return a > b ? a : b;
}
int main()
{
    .....
	return 0;
}

函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般有4个步骤

  1. 创建后缀名为.h的头文件
  2. 创建后缀名为.cpp的源文件
  3. 在头文件中写函数的声明
  4. 在源文件中写函数的定义

add.h

#ifndef DEMO01_ADD_H
#define DEMO01_ADD_H

#include "iostream"
using namespace std;

int add(int num1,int num2);
#endif //DEMO01_ADD_H

add.cpp

#include "add.h"
int add(int num1,int num2)
{
    return num1+num2;
}

main.cpp

#include <iostream>
#include "add.h"
using namespace std;
int main()
{
    int a=3,b=4,sum;
    sum= add(a,b);
    cout<<sum<<endl;
    return 0;
}

指针

基本概念

指针的作用： 可以通过指针间接访问内存

  • 内存编号是从0开始记录的，一般用十六进制数字表示
  • 可以利用指针变量保存地址

指针变量的定义和使用

指针变量定义语法： 数据类型 * 变量名；

int main()
{
    int a=10;
    int *p;
    p=&a;
    cout<<"&a="<<&a<<endl;
    cout<<"p="<<p<<endl;
    cout<<"a="<<a<<endl;
    cout<<"*p="<<*p<<endl;
    return 0;
}
/*
&a=0x61fe14
p=0x61fe14
a=10
*p=10
*/

指针变量和普通变量的区别

  • 普通变量存放的是数据,指针变量存放的是地址
  • 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

总结1： 我们可以通过 & 符号 获取变量的地址

总结2：利用指针可以记录地址

总结3：对指针变量解引用，可以操作指针指向的内存

指针内存空间

cout<<"sizeof(int *)="<<sizeof(int *)<<endl;
cout<<"sizeof(float *)="<<sizeof(float *)<<endl;
cout<<"sizeof(double *)="<<sizeof(double *)<<endl;
cout<<"sizeof(char *)="<<sizeof(char *)<<endl;
/*
sizeof(int *)=8
sizeof(float *)=8
sizeof(double *)=8
sizeof(char *)=8
*/
  • 所有指针类型在32位操作系统下是4个字节
  • 所有指针类型在64位操作系统下是8个字节

空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

int main()
{
        //指针变量p指向内存地址编号为0的空间
        //用于指针初始化
        int * p = NULL;
        //访问空指针报错
        //内存编号0 ~255为系统占用内存，不允许用户访问
        cout << *p << endl;
        return 0;
}

野指针：指针变量指向非法的内存空间

int main() {
	//指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;
	//访问野指针报错 
	cout << *p << endl;
	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

const修饰指针

const修饰指针有三种情况

  • const修饰指针 — 常量指针
  • const修饰常量 — 指针常量
  • const既修饰指针，又修饰常量
int main() {
	int a = 10;
	int b = 10;
	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	
	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	return 0;
}

数组和指针

int main()
{
    int arr[6]={1,2,3,4,5,6};
    int *p=arr;
    cout<<"第一个元素为:"<<*p<<endl;
    cout<<"第二个元素为:"<<*++p<<endl;
    int *n=arr;
    for(int i=0;i<6;i++)
    {
        cout<<*n+i<<' ';
    }
    cout<<endl;
    return 0;
}
/*
第一个元素为:1
第二个元素为:2
1 2 3 4 5 6
*/

指针与函数

//值传递
void swap(int *a, int *b) {
    int t;
    t = *a;
    *a = *b;
    *b = t;
    cout << "a=" << *a << endl;
    cout << "b=" << *b << endl;
}
int main()
{
    int a=7;
    int b=3;
    swap(&a, &b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
}
/*
a=3
b=7
a=3
b=7
*/

指针与函数和数组

void sort_arr(int *p, int length)
{
    int i, j, t;
    int a=*p;
    for(i=0;i<length-1;i++)
    {
        for(j=0;j<length-1-i;j++)
        {
            if(p[j] > p[j+1])
            {
                t = p[j];
                p[j] = p[j+1];
                p[j+1] = t;
            }
        }
    }
}
int main()
{
    int arr[10] = {4, 3, 1, 0, 9, 8, 2, 7, 3, 10};
    int l = sizeof(arr)/sizeof(arr[0]);
    sort_arr(arr, l);
    for(int i=0; i<l-1; i++)
        cout<<arr[i]<<' ';
    cout<<endl;
    return 0;
}
/*
0 1 2 3 3 4 7 8 9
*/

结构体

结构体定义

struct 结构体名 {结构体类型}

#include <iostream>
#include <string>
using namespace std;
//创建学生数据类型
//自定义数据类型，一些类型集合组成的一个类型
struct Student
{
    string name;
    int age;
    int score;
} s3;
//定义类型方式
//struct Student s1;
//struct Student s2={.....}
//struct Student {.....}s3;
int main()
{
    //struct关键字可以省略
    Student s1;
    //struct Student s1;
    s1.name = "大明";
    s1.age = 18;
    s1.score = 90;
    cout<<"姓名:"<<s1.name<<" 年龄:"<<s1.age<<" 分数:"<<s1.score<< endl;
    s3.name = "小丽";
    s3.age = 20;
    s3.score = 88;
    cout<<"姓名:"<<s3.name<<" 年龄:"<<s3.age<<" 分数:"<<s3.score<< endl;
    return 0;
}
/*
姓名:大明 年龄:18 分数:90
姓名:小丽 年龄:20 分数:88
*/

结构体数组

作用：将自定义的结构体放入到数组中方便维护

struct People
{
    string name;
    int age;
    float weight;
};
int main()
{
    People people_demo[3]=
            {
            {"张三", 18, 57},
            {"小丽", 19, 48.2},
            {"小花", 17, 45.6}
            };
    people_demo[2].name="张三";
    people_demo[0].age = 19;
    for(int i=0; i<3; i++)
    {
        cout<<"name:"<<people_demo[i].name<<" age:"<<people_demo[i].age<<" weight:"<<people_demo[i].weight<<endl;
    }
    return 0;
};
/*
name:张三 age:19 weight:57
name:小丽 age:19 weight:48.2
name:张三 age:17 weight:45.6
*/

结构体指针

struct People
{
    string name;
    int age;
    float weight;
};
int main()
{
    People s = {"张三", 18, 58.3};
    People *p=&s;
    cout<<"name:"<<p->name<<endl;
    cout<<"age:"<<p->age<<endl;
    cout<<"weight:"<<p->weight<<endl;
    return 0;
}
/*
name:张三
age:18
weight:58.3
*/

结构体嵌套结构体

struct Student
{
    string name;
    int age;
    float score;
};
struct Teacher
{
    string name;
    int age;
    struct Student stu;
};
int main()
{
    Teacher t;
    t.name = "王老师";
    t.age = 56;
    t.stu.name = "小王";
    t.stu.age = 18;
    t.stu.score = 90.5;
    cout<<"Teacher name:"<<t.name<<" Teacher age:"<<
    t.age<<" stu name:"<<t.stu.name<<" stu age:"
    <<t.stu.age<<" stu score:"<<t.stu.score<<endl;
    return 0;
}
/*
Teacher name:王老师 Teacher age:56 stu name:小王 stu age:18 stu score:90.5
*/

结构体做函数参数

struct Student
{
    string name;
    int age;
    float score;
};
void printfstu1(Student stu)
{
    stu.age = 20;
    cout<<"------子函数1-------"<<endl;
    cout<<"name:"<<stu.name<<" age:"<<stu.age<<" score:"<<stu.score<<endl;
}
void printfstu2(Student *p)
{
    p->age = 30;
    cout<<"------子函数2-------"<<endl;
    cout<<"name:"<<p->name<<" age:"<<p->age<<" score:"<<p->score<<endl;
}
int main()
{
    Student stu;
    stu.name = "张三";
    stu.age = 18;
    stu.score = 90.5;
    printfstu1(stu);
    cout<<"------主函数1后-------"<<endl;
    cout<<"name:"<<stu.name<<" age:"<<stu.age<<" score:"<<stu.score<<endl;
    printfstu2(&stu);
    cout<<"------主函数2后-------"<<endl;
    cout<<"name:"<<stu.name<<" age:"<<stu.age<<" score:"<<stu.score<<endl;
    return 0;
}
/*
------子函数1-------
name:张三 age:20 score:90.5
------主函数1后-------
name:张三 age:18 score:90.5
------子函数2-------
name:张三 age:30 score:90.5
------主函数2后-------
name:张三 age:30 score:90.5
*/

结构体案例1

#include <iostream>
#include <string>
using namespace std;
struct Student
{
    string name;
    int score;
};
struct Teacher
{
    string name;
    Student Array[5];
};
void allowStuTea(Teacher array[], int length)
{
    string nameSeed="ABCDEFGHIKLMNOP";
    int score[3][5]={{56, 93, 86, 76, 40},
                     {66, 80, 33, 77, 90},
                     {96, 88, 47, 60, 70}};
    for(int i=0;i<length;i++)
    {
        array[i].name="teacher_";
        array[i].name += nameSeed[i];
        for(int j=0;j<5;j++)
        {
            array[i].Array[j].name = "student_";
            array[i].Array[j].name += nameSeed[i*5+j];
            array[i].Array[j].score = score[i][j];
        }
    }
}
void Infomsg(Teacher array[], int length)
{
    for(int i=0;i<length;i++)
    {
        cout<<"老师姓名:"<<array[i].name<<endl;
        for(int j=0;j<5;j++)
        {
            cout<<"学生姓名:"<<array[i].Array[j].name<<" 成绩:"<<array[i].Array[j].score<<endl;
        }
        cout<<"--------------"<<endl;
    }
}
int main()
{
    Teacher tArray[3];
    int len=sizeof(tArray)/sizeof(tArray[0]);
    allowStuTea(tArray, len);
    Infomsg(tArray, len);
}
/*
老师姓名:teacher_A
学生姓名:student_A 成绩:56
学生姓名:student_B 成绩:93
学生姓名:student_C 成绩:86
学生姓名:student_D 成绩:76
学生姓名:student_E 成绩:40
--------------
老师姓名:teacher_B
学生姓名:student_F 成绩:66
学生姓名:student_G 成绩:80
学生姓名:student_H 成绩:33
学生姓名:student_I 成绩:77
学生姓名:student_K 成绩:90
--------------
老师姓名:teacher_C
学生姓名:student_L 成绩:96
学生姓名:student_M 成绩:88
学生姓名:student_N 成绩:47
学生姓名:student_O 成绩:60
学生姓名:student_P 成绩:70
--------------
*/

结构体案例2

#include <iostream>
#include <string>
using namespace std;

struct Hero
{
    string name;
    int age;
    string sex;
};
void Infomsg(Hero arr[], int len);
void sortHero(Hero arr[], int len);
int main()
{
    Hero heroArr[5]={{"刘备", 30, "男"},
                     {"关羽", 32, "男"},
                     {"张飞", 31, "男"},
                     {"赵云", 28, "男"},
                     {"貂蝉", 24, "女"}};
    int length=sizeof (heroArr)/sizeof (heroArr[0]);
    Infomsg(heroArr, length);
    sortHero(heroArr, length);
    Infomsg(heroArr, length);
}
void Infomsg(Hero arr[], int len)
{
    cout<<"------------"<<endl;
    for (int i=0;i<len;i++)
    {
        cout<<"name:"<<arr[i].name<<" age:"<<arr[i].age<<" sex:"<<arr[i].sex<<endl;
    }
}
void sortHero(Hero arr[], int len)
{
    Hero temp;
    for (int i=0;i<len-1;i++)
    {
        for(int j=0;j<len-1-i;j++)
        {
            if(arr[j].age>arr[j+1].age)
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
/*
------------
name:刘备 age:30 sex:男
name:关羽 age:32 sex:男
name:张飞 age:31 sex:男
name:赵云 age:28 sex:男
name:貂蝉 age:24 sex:女
------------
name:貂蝉 age:24 sex:女
name:赵云 age:28 sex:男
name:刘备 age:30 sex:男
name:张飞 age:31 sex:男
name:关羽 age:32 sex:男
*/
于小猿Sup
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 7万+
C/C++学习路线总结与分享
编程C++基础资源学习
11-14
c++语言在近年来深度学习算法性能提高方面也有着重要的作用，本资源将所有C++基础知识全面提纲式总结，供读者自学或者参考学习。本资源可以作为期末考试或者考研学子的参考资料，也可以作为求职者笔试面试应聘的复习...
关于C++中的二维数组
weixin_52788252的博客
09-30 168
关于C++中的二维数组 关于二维数组在内存中的排列 当我们声明一个数组 如：nt arr[2][2] = {{1,2},{3,4}}; 我们假设该数组的起始地址为0，那么直接输出arr的地址便为0，且范围是0~7，占用8个字节。然而有趣的是arr+1的地址并非为4，而是为8。因此，想要输出行之中列的地址，需要在arr的地址上再进行操作，即 （*arr+0）+1，这便得到了数组中第一行第二列数值的地址； 输出分为以下 （1）cout << arr ;将会输出首位的地址； （2）cout <&
蓝桥环，用C++建立一个二维数组，并对其输出。
weixin_63236032的博客
09-13 347
【代码】蓝桥环，用C++建立一个二维数组，并对其输出。
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
Qt学习之C++基础
RongLin02的博客
10-03 1万+
C++面向对象 类
C++入门基础（万字详解！！！）
忘忧.
08-15 3万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
零基础如何学习C++
bingLLL的博客
08-15 837
一说起C++很多人就头疼，都会说这个是高级语言，太难了，而我想说的是，首先无论学习任何技能，你必须有一个清晰的版图，有一个逻辑，你为何什么要学这个，学这个是为了什么，这个工作的条件是那些？是不是决定要从事这个职业？这些都是你一开就要考虑的问题。 最后你要有一个非常清晰的学习大纲，随时记住我们在学习任何东西都要系统，不可胡乱的瞎学浪费时间。我们的青春是耗不起的，我们要醒着拼。做任何事情，不要...
C++基础入门
a577715979的博客
01-02 5066
C++入门
C++部署深度学习模型
Fantastic
07-24 7510
在部署大规模深度学习应用的时候，要想满足应用需求或者压榨模型的性能，C++可能是比python更好的选择方案。基于此，特地记录最近的C++的学习经历。其实以终为始来思考为什么学习C++，首先是为了能够很好地提升模型的性能，满足应用场景中的高可用，高并发，低时延等要求。为了提升模型的性能，需要用到一些推理框架，如TensorRT、NCNN或者Openvino（本文中以TensorRT作为案例）。TensorRT在8.0以上的版本都支持Python的API了，但还是有必要学习C++。ONNX模型转换和优化。..
C++学习必备网站推荐收藏
xu_fu_yong的专栏
03-09 1万+
在 C++ 的学习过程中离不开阅读大量的免费文档和网站，今天在此分享一些值得收藏的C++学习网站，希望对大家有所帮助。
C++基础学习笔记.pdf
01-30
适用人群：C++初学者及C++期末考试冲刺 此C++学习笔记是本人在学习中思考总结所得，能够很好地帮助你入门C++或冲刺期末考试，让你掌握C++基础。
C++基础编程 学习笔记
05-13
C++基础编程，适合小白和跨专业的同学学习，涉及 C++介绍（注释，变量，关键字，标识符命名规则）、 数据类型（整型，sizeof关键字，实型（浮点型），字符型，布尔型，数据的输入）、 运算符（算数运算符，赋值...
C++基础学习资料.rar
06-03
C++基础学习资料.rar
C++基础知识学习总结
02-24
总之，C++的基础知识是深入学习和应用C++的基石。通过理解和实践这些概念，可以逐步提升编程技能，进而开发出高效、可靠和可维护的软件系统。无论是初学者还是经验丰富的开发者，不断巩固和深化C++的基础知识都至关...
C/C++ 提取DNS请求/响应数据包之中的 Quesion 内容
liulilittle的博客
06-20 300
它主要是提取DNS数据包之中查询问题的信息，如：问题类型、问题类别、问题内容（域/IP），我们如果想要对于某个DNS数据包需要进行遥测的时，或者进行NS缓存生命周期管理，那么就需要类似这样的函数实现了。
C语言 指定一个数字输出区间内的一个斐波那契数列
Random_N1的博客
06-20 362
/ 函数用于计算并打印从1到n的斐波那契数列a = b;b = next;int num;return 0;
线程简介及其函数使用实例（gcc *.c -lpthread）
CSDN_DU666666的博客
06-20 398
线程概念、线程接口提供方式、线程创建使用到的函数、多线程创建实例 、多线程创建实例 、多线程执行顺序问题和多线程占用内存问题
C语言第17篇：预处理详解
最新发布
2302_78977491的博客
06-22 760
C语言设置了一些预定义符号，可以直接使用。预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1, 否则未定义int main()printf("进行编译的源文件:%s\n", __FILE__);printf("当前文件的行号:%d\n", __LINE__);

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值