C++基础学习笔记（上）

最新推荐文章于 2023-06-13 22:54:32 发布

VIP文章 MegaBytes

最新推荐文章于 2023-06-13 22:54:32 发布

阅读量119

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/mbytes/article/details/114630260

版权

C++基础学习笔记（上）

文章目录

C++基础学习笔记（上）

一、常量

1.宏常量：通常在文件上方，使用#define 常量名常量值定义；

2.const修饰的变量：const 数据类型常量名 = 常量值，不可修改。

二、数据类型：

1.整型：

short：短整型，2B，-32768~32767

int：整型，4B，-2^31~231-1

long：长整型，win 4B，Unix 4B（32b），8B（64b）

long long：8B

2.sizeof()关键字可以统计数据类型占的内存大小。

3.实型（浮点型）：

float：4B

double：8B

科学计数法：f = 3e-2

4.字符型：char 1B，字符型变量将字符对应的ASCII码放到存储单元。

5.字符串型:

char 变量名[] = ”xx“ ——C风格

string 变量名 = ”xx“ ——C++风格

6.bool型：1B

7.数据输入：cin >> 变量

8.前置递增：先让变量递增，再进行表达式运算。后置递增： 先进行表达式运算，再让变量递增。

三、程序流程结构

1.三目运算符返回的是变量，可以继续赋值。

2.do-while循环：do{循环语句} while{循环条件}，与while的区别在于先执性一次循环语句，再判断循环条件。

do {
   
    cout << num << endl;
    num ++;
}
while(num < 10);

水仙花数：

do {
   
    int i = num % 10;
    int j = num / 10 % 10;
    int k = num / 100;
    if (i*i*i  + j*j*j + k*k*k == num){
   
        cout << num << endl;
    }
    num ++;
}
while(num < 1000);

3.for(起始表达式;条件表达式;末尾循环体){循环语句;} 等价于下：

int i = 0;
for (;;) {
   
    if(i > 10){
   break;}
    cout << i <<endl;
    i ++;
}

continue本次循环剩下的代码不执行。

4.goto标记:如果标记的名称存在，执行到goto语句时会跳转到标记的位置。

goto FLAG;
FLAG:
cout << "goto!!" << endl;

四、数组

1.数组放在一块连续的内存空间中，每个元素都是相同的数据类型。创建方式：

int arr[5];

int arr[] = {1, 2, 3, 4, 5};

int arr[];

2.冒泡排序：

for (int i = 0; i < size - 1; ++i) {
   //总轮数为元素个数-1
    for (int j = 0; j < size - i - 1 ; ++j) {
   //对比次数 = 元素个数 - 当前轮数 - 1
        if (arr[j] > arr[j+1]){
   
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

五、函数

1.函数的声明：函数写在main函数之后会找不到函数，需要事先声明。声明函数只有函数类型、函数名和参数列表。声明可以写多次，但函数定义只能有一次。

2.函数的分文件编写：

（1）创建.h头文件；（2）创建.cpp源文件；（3）在头文件中写函数的声明；（4）在源文件中写函数的定义，包含头文件。

六、指针（int *类型）

1.指针变量保存一个地址。通过解引用的方式使用指针：*p

2.指针在32b系统下占4B，在64b系统占8B；

3.空指针：指针变量指向内存中编号为0的空间，一般用于初始化指针变量：int *p = NULL;空指针指向的内存不允许访问,0-255的内存编号是系统使用。

4.野指针：指针变量指向非法内存空间。空指针和野指针都市自己申请的空间，不允许访问。

5.const修饰指针（3种情况）：

const修饰指针：常量指针：const int * p = &a；指针的指向可以修改，但指针指向的值不能修改。

const修饰常量：指针常量：int * const p = &a；指针的指向不可以修改，但指针指向的值可以修改。

const既修饰指针又修饰常量：const int * const p = &a；指针的指向和指向的值都不能修改。

6.利用指针访问数组中的元素：

int arr[] = {
   1,2,3,4,5,6,7,8,9};
int * p = arr;//指向数组首地址
for (int i = 0; i < 9; ++i) {
   
    cout << *p << endl;
    p++;//指针向后偏移4B
}

7.指针和函数：在函数中需要修改传入的实参，则需要传入地址。

8.指针、数组、函数实现冒泡排序：

void bubbleSort(int * arr, int len){
   
    cout << "arr:" << arr <<endl;//arr地址
    cout << "* arr:" << * arr <<endl;//数组首元素
    for (int i = 0; i < len - 1; ++i) {
   
        for (int j = 0; j < len - i - 1; ++j) {
   
            if (arr[j] > arr[j+1]){
   
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
void printArr(int * arr, int len){
   
    for (int i = 0; i < len; ++i) {
   
        cout << arr[i] << endl;
    }
}
int main(){
   
    int arr[] = {
   12,2,5,4,1,6,17,28,9,3};
    int len = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, len);
    printArr(arr, len);
}

七、结构体

1.结构体是用户自定义的数据类型，允许存储不同的数据类型。语法：struct 结构体名 { 结构体成员列表 }；通过结构体创建变量的方式有三种（常用一二种），创建时struct关键字可胜省略，定义时不可省略：

struct 结构体名变量名

struct 结构体名变量名 = {成员1值, 成员2值…}

定义结构体时顺便创建变量

struct Student{
   
    string name;
    int age;
    int score;
} s3;//第三种
int main(){
   
    //第一种
    struct Student s1;
    s1.name = "a";
    s1.age = 13;
    s1.score = 100;
    //第二种
    struct Student s2 = {
   "b", 18, 99};
    //第三种
    s3.name = "c";
    s3.age = 22;
    s3.score = 66;
}

2.结构体数组：将自定义的结构体放入数组中方便维护。语法：struct 结构体名数组名[元素个数] = { {}, {}, {}, …}

struct Student{
   
    string name;
    int age;
    int score;
};
int main(){
   
    Student stuArr[3] = {
   
            {
   "a", 16, 100},
            {
   "b", 18,99},
            {
   "c",22,66}
    };
    stuArr[0].name = "d";//修改结构体变量
    for (int i = 0; i < 3; ++i) {
   //遍历输出结构体变量
        cout << stuArr[i].name << stuArr[i].age << stuArr[i].score << endl;
    }
}

3.结构体指针：作用：通过指针访问结构体中的成员。利用操作符 -> 可以通过结构体指针访问结构体属性。

struct Student{
   
    string name;
    int age;
    int score;
};
int main(){
   
   Student s = {
   "a", 16, 100};
   Student * p = &s;//通过指针指向结构体变量
   cout << "姓名：" << p->name << endl;
}

4.结构体嵌套结构体：例：一个老师带多个学生。

struct Student{
   
    string name;
    int age;
    int score;
};
struct Teacher{
   
    int id;
    string name;
    int age;
    struct Student stu;
};
int main(){
   
   Teacher t;
   t.id = 1;
   t.name = "王老师";
   t.age = 45;
   t.stu.name = "小明";
   t.stu.age = 20;
   t.stu.score = 100;
   cout << t.name << t.id << t.age << t.stu.name << t.stu.age << endl;
}

5.结构体做函数参数：作用：将结构体作为参数向函数中传递，传递方式有值传递和地址传递。

struct Student{
   
    string name;
    int age;
    int score;
};
void printStu(Student * s){
   
    cout << s->name << s->age << s->score << endl;
}
int main(){
   
    Student s;
    s.name = "小明";
    s.age = 18;
    s.score = 100;
    printStu(&s);
}

6.结构体重const使用：用来防止误操作。

//将函数的形参改为指针可以减少占用内存空间，而且不会复制新的副本出来。
//但会有误修改结构体数据的风险。使用const可以避免，有修改的操作会报错
void printStu(const Student * s){
   
    cout << s->name << s->age << s->score <<endl;
}
int main(){
   
    Student s = {
   "小明", 18, 100};
    printStu(&s);
}

7.例：每个老师带五个学生

struct Student{
   
    string sName;
    int score;
};
struct Teacher{
   
    string tName;
    Student sArr[5];
};
void allocateSpace(Teacher tArr[], int len){
   
    string nameSeed = "ABCDE";
    for (int i = 0; i < len; ++i) {
   
        tArr[i].tName = "teacher_";
        tArr[i].tName += nameSeed[i];
        for (int j = 0; j < 5; ++j) {
   
            tArr[i].sArr[j].sName = "student_";
            tArr[i].sArr[j].sName += nameSeed[j];
            tArr[i].sArr[j].score = 66;
        }
    }
}
void printInfo(Teacher tArr[], int len){
   
    for (int i = 0; i < len; ++i) {
   
        cout << "老师姓名：\t" << tArr[i].tName << endl;
        for (int j = 0; j < 5; ++j) {
   
            cout << "学生姓名:\t" << tArr[i].sArr[j].sName << "学生分数：\t" << tArr[i].sArr[j].score << endl;
        }
    }
}
int main(){
   
    //创建三个老师的数组
    Teacher tArr[3];
    //给三老师和其学生赋值
    int len = sizeof(tArr) / sizeof(tArr[0]);
    allocateSpace(tArr, len);
    //输出老师和学生信息
    printInfo(tArr, len);
}

8.例：冒泡排序输出按结构体的某个值排序结果：

struct Hero{
   
    string name;
    int age;
    string sex;
};
void bubbleSort(Hero heroArr[], int len){
   
    for (int i = 0; i < len - 1; ++i) {
   
        for (int j = 0; j < len - i - 1; ++j) {
   
            if (heroArr[j].age > heroArr[j+1].age){
   
                Hero temp = heroArr[j];
                heroArr[j] = heroArr[j+1];
                heroArr[j+1] = temp;
            }
        }
    }
}
void printArr(Hero heroArr[],int len){
   
    for (int i = 0; i < len; ++i) {
   
        cout << "名字：" << heroArr[i].name

最低0.47元/天解锁文章

MegaBytes

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++基础学习笔记（上）

C++基础学习笔记（上）文章目录C++基础学习笔记（上）一、常量二、数据类型：三、程序流程结构四、数组五、函数六、指针（int \*类型）七、结构体八、内存模式——内存四区（代码区、全局区、栈区、堆区）九、引用十、函数提高十一、类和对象十二、运算符重载十三、继承十四、多态十五、文件一、常量1.宏常量：通常在文件上方，使用#define 常量名常量值定义；2.const修饰的变量：const 数据类型常量名 = 常量值，不可修改。二、数据类型：1.整型： short：短整型，2B，-32
复制链接

扫一扫