【C\C++】基础语法

已于 2022-02-17 21:18:10 修改
阅读量422 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c语言 c++ 算法
于 2022-02-17 15:19:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jruo911/article/details/122981207
版权

指针

int a=0;
&a 是地址
0是 &a这个地址的值

int a=0;
int *p;
p=&a;
// *p作用就是：取指针p的指向的地址，再取这个地址的值！相当于*(&a)=a

*p=*p+1;   //相当于a=a+1 , *(&a)=*(&a)+1
// *p+1作用就是：先取指针p的指向的地址，再取这个地址的值，最后把值加1替换这个地址的原来的值！

p=p+1;  //相当于在p的值中加了一个int类型的大小存储单元，就是加4：&a+4  
// p:0x61fe14 -> 0x61fe18
// *p:6422040

交换

// 相当于复制了一个副本
void swap(int x, int y) {
    int temp;
    temp= x;
    x = y;
    y = temp;
}

int main() {
    int a = 2, b = 3;
    printf("before:%d,%d\n", a, b); // 2,3
    swap(a, b);
    printf("later:%d,%d\n", a, b);  // 2,3
    return 0;
}

// 相当于x=a=&p，int*是类型 *x=*a 
// *x就相当于取指针a的指向的地址，再取这个地址的值！
// 然后 "//2" 把这个地址的值替换为 *y，即此时*a=3了
void swap(int* x, int* y) {
    int temp; 
    temp = *x;//1
    *x = *y;  //2
    *y = temp;//3
}

int main() {
    int p = 2, q = 3;
    int* a = &p, * b = &q;
    printf("before:%d,%d\n", *a, *b); // 2,3
    swap(a, b);
    printf("later:%d,%d\n", *a, *b);  // 3,2
    return 0;
}

C++引用

#include<stdio.h>
#include<iostream>

using namespace std;
// 引用传递，可以理解为a就是x，x就是a，只不过名字不一样
void swap(int& x, int& y) {
    int temp;
    temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 2, b = 3;
    printf("before:%d,%d\n", *a, *b);  // 2,3
    swap(a, b); 
    printf("later:%d,%d\n", *a, *b);   // 3,2
    return 0;
}

字符串

#include<stdio.h>
#include<iostream>

using namespace std;


int main() {
    // char* s1;
    // s1 = "abc";

    char s2[] = "abc";
    char s3[] = { "abc" };
    char s4[] = { 'a','b','c' };
    
    // char* s5;
    // s5 = { "abc" };
    
    for (int i = 0; i < 3; i++) {
        cout << s2[i];// s2[i],s3[i],s4[i] 都可以
    }



    return 0;
}

typedef

【参考：C语言中struct typedef 以及结构体指针用法_乌鸦大大-CSDN博客】
typedef是类型定义的意思 type defined

普通变量

struct Student
{
   int no;
   char name[12];
}Stu; // 定义了一个结构体Stu变量
已经定义了一个结构体Stu变量，如果要重新新建，就必须用struct Student stu1;

typedef struct
{
   int no;
   char name[12];
}Stu; // 定义了一个结构体Stu变量
如果使用了typedef，而且这里也不写Student（于是也不能struct Student stu1;了）

typedef struct Student
{
   int no;
   char name[12];
}Stu,stud; // Student写了就必须定义结构体变量，要不然有的编译器会报错
在声明变量的时候就可：Stu stu1;或者：stud stu2;(Stu 和stud 同时为Student的别名)
struct Student stu3;

举例

typedef struct Queue // 结构体名
{
    int data[maxSize];
    //设置队头和队尾
    int front; // front为当前队头元素的前一个位置
    int rear;
}Queue; // 结构体变量

Queue Q; // Queue 是结构体变量
struct Queue Q // Queue 是结构体名

结构体指针

typedef struct BTNode{
	int data;
	struct BTNode *lchild;
	struct BTNode *rchild;
}BTNode,*btnode;

BTNode *p;等价于btnode p;


一般使用
BTNode *p;
p=(BTNode *)malloc(sizeof(BTNode)); // void* malloc(int size)

引用

C++引用相当于取别名

指向普通变量的引用


void func(int &x){ // 这里不是取地址，而是引用
	++x;
}
int x=1;
func(x); // 传入普通变量
printf("%d",x);// 2

指向指针变量的引用
相当于给指针变量取别名
也相当于C语言中的二级指针

void func(int* &x){ // 这里不是取地址，而是引用
	++(*x);
}
int p = 1;
int* x = &p;
func(x);// 传入指针变量x
printf("%d",*x);// 2

队列

循环队

必须损失一个存储空间来区分队空和队满
顺时针转动，元素夹在(front,rear]之间

队空 Q.front == Q.rear

队满 (Q.rear + 1) % maxSize == Q.front

front为当前队头元素的前一个位置
在这里插入图片描述

c语言

// 简单写法
int Queue[maxSize];
int front,rear;
front=rear=0;


#include<stdio.h>

#define maxSize 10

// 顺序队
struct Queue
{
    int data[maxSize];
    //设置队头和队尾
    int front; // front为当前队头元素的前一个位置
    int rear;
};
// C语言没有bool类型
// 需要修改Q，所以需要传指针
int InitQueue(Queue* Q) {
    Q->front = Q->rear = 0;
    return 1;
}
// 不需要修改Q，所以不用传指针
int isEmpty(Queue Q) {
    if (Q.front == Q.rear) // 队空
        return 1;
    else
        return 0;
}

int pushQueue(Queue* Q, int e) {
    if ((Q->rear + 1) % maxSize == Q->front) { // 队满
        return 0;
    }
    Q->rear = (Q->rear + 1) % maxSize; // 后移一位
    Q->data[Q->rear] = e;
    return 1;
}
// 出队并返回该元素
int popQueue(Queue* Q, int* e) {
    if (Q->front == Q->rear) // 队空
        return 0;
    Q->front = (Q->front + 1) % maxSize; // 后移一位
    *e = Q->data[Q->front];
    return 1;
}

int length(Queue Q) {
    return (Q.rear - Q.front + maxSize) % maxSize;
}

void printQueue(Queue Q) {
    while (!isEmpty(Q))
    {
        int e;
        popQueue(&Q, &e);
        printf("%d\n", e);
    }

}

int main() {

    struct Queue Q;

    InitQueue(&Q);
    pushQueue(&Q, 1);
    pushQueue(&Q, 2);
    pushQueue(&Q, 3);
    pushQueue(&Q, 4);

    int e;
    popQueue(&Q, &e);
    printf("%d\n", e);//1
    printf("%d\n", length(Q));//3

    printQueue(Q);
    return 0;
}

c++ 引用

#include<stdio.h>

#define maxSize 10

// 顺序队
typedef struct
{
    int data[maxSize];
    //设置队头和队尾
    int front; // front为当前队头元素的前一个位置
    int rear;
}Queue;
// C语言没有bool类型
// 需要修改Q，所以需要传引用，&是引用符号
int InitQueue(Queue& Q) {
    Q.front = Q.rear = 0;
    return 1;
}
// 不需要修改Q，所以不用传引用
int isEmpty(Queue Q) {
    if (Q.front == Q.rear) // 队空
        return 1;
    else
        return 0;
}

int pushQueue(Queue& Q, int e) {
    if ((Q.rear + 1) % maxSize == Q.front) { // 队满
        return 0;
    }
    Q.rear = (Q.rear + 1) % maxSize; // 后移一位
    Q.data[Q.rear] = e;
    return 1;
}
// 出队并返回该元素
int popQueue(Queue& Q, int& e) {
    if (Q.front == Q.rear) // 队空
        return 0;
    Q.front = (Q.front + 1) % maxSize; // 后移一位
    e = Q.data[Q.front];
    return 1;
}

int length(Queue Q) {
    return (Q.rear - Q.front + maxSize) % maxSize;
}

void printQueue(Queue Q) {
    while (!isEmpty(Q))
    {
        int e;
        popQueue(Q, e);
        printf("%d\n", e);
    }

}

int main() {

    Queue Q;

    InitQueue(Q);
    pushQueue(Q, 1);
    pushQueue(Q, 2);
    pushQueue(Q, 3);
    pushQueue(Q, 4);

    int e;
    popQueue(Q, e);
    printf("%d\n", e);//1
    printf("%d\n", length(Q));//3

    printQueue(Q);
    return 0;
}

栈

顺序栈

// 简单写法
int Stack[maxSize];
int top-1;

stack[++top]=x;// 进栈
x=stack[top--];// 出栈


#include<stdio.h>

#define maxSize 10

// 顺序队
struct stack
{
    int data[maxSize];
    int top; // 栈顶
};

int Initstack(stack* st) {
    st->top = -1; // 栈空
    return 1;
}

int isEmpty(stack st) {
    if (st.top == -1)
        return 1;
    else
        return 0;
}

int pushstack(stack* st, int e) {
    if (st->top == maxSize - 1) { //栈满 0~maxSize - 1
        return 0;
    }
    (st->top)++;
    st->data[st->top] = e;
    return 1;
}
// 出队并返回该元素
int popstack(stack* st, int& e) {
    if (st->top == -1)
        return 0;
    e = st->data[st->top];
    (st->top)--;
    return 1;
}

int length(stack st) {
    return st.top + 1; // 加上data[0]	
}

void printstack(stack st) {
    while (!isEmpty(st))
    {
        int e;
        popstack(&st, e);
        printf("%d\n", e);
    }

}

int main() {

    struct stack st;

    Initstack(&st);
    pushstack(&st, 1);
    pushstack(&st, 2);
    pushstack(&st, 3);
    pushstack(&st, 4);

    int e;
    popstack(&st, e);
    printf("%d\n", e);//4
    printf("%d\n", length(st));//3

    printstack(st);
    return 0;
}

c++引用

#include<stdio.h>

#define maxSize 10

// 顺序队
struct stack
{
    int data[maxSize];
    int top; // 栈顶
};

int Initstack(stack& st) {
    st.top = -1; // 栈空
    return 1;
}

int isEmpty(stack st) {
    if (st.top == -1)
        return 1;
    else
        return 0;
}

int pushstack(stack& st, int e) {
    if (st.top == maxSize - 1) { //栈满 0~maxSize - 1
        return 0;
    }
    (st.top)++;
    st.data[st.top] = e;
    return 1;
}
// 出队并返回该元素
int popstack(stack& st, int& e) {
    if (st.top == -1)
        return 0;
    e = st.data[st.top];
    (st.top)--;
    return 1;
}

int length(stack st) {
    return st.top + 1; // 加上data[0]
}

void printstack(stack st) {
    while (!isEmpty(st))
    {
        int e;
        popstack(st, e);
        printf("%d\n", e);
    }

}

int main() {

    struct stack st;

    Initstack(st);
    pushstack(st, 1);
    pushstack(st, 2);
    pushstack(st, 3);
    pushstack(st, 4);

    int e;
    popstack(st, e);
    printf("%d\n", e);//4
    printf("%d\n", length(st));//3

    printstack(st);
    return 0;
}

C++

参考《C++面向对象程序设计教程》第三版 陈维兴 林小茶 清华大学出版社

输出

#include<iostream>
using namespace std;


int main()
{
    int x = 30;
    cout << dec << x << endl; // 30 十进制
    cout << hex << x << "\n"; // 1e 八进制
    cout << oct << x << endl; // 36 十六进制
    return 0;
}

const

  • 1.指向常量的指针：一个指向常量的指针变量 (地址可变)
    const char* name=“chen”;
    不允许改变指针所指地址中的常量：name[3]=‘a’; ×
    但可以改变name所指的地址：name=“zhang”;

  • 2.常指针：把指针所指的地址声明为常量，即不能移动的指针（数据可变）
    char* const name=“chen”;
    允许改变指针所指地址中的数据：name[3]=‘a’;
    不允许改变name所指的地址：name=“zhang”; ×

  • 3.指向常量的常指针：（数据和地址都不可变）
    const char* const name=“chen”;
    不允许改变指针所指地址中的数据：name[3]=‘a’; ×
    不允许改变name所指的地址：name=“zhang”; ×

int可以省略
const int LIMIT=100;
const LIMIT=100;

myaijarvis
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++基础语法
weixin_45820912的博客
12-07 2261
C是一个结构化语言，如谭老爷子所说：它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。 希望能与大家一起交流讨论编程的魅力 加群：590750544 (群里有编程...
【基础】C++语法
字节跳动
02-29 842
C++语法
C++基础学习笔记——Const修饰符
qq_40754866的博客
02-27 629
const 修饰符 在C中，习惯使用 #define来定义常量，例如： #define LIMIT 100 ; C++提供了一种更灵活、更安全的方式来定义常量， 即使用 const 修饰符来定义常量，例如： const int LIMIT = 100； 这个常量是类型化的，它有地址，可以用指针指向这个值，但不能修改它。 const 也可以与指针一起使用，它们的组合情况较复杂，可归纳为三种：指向...
char \*const name和const char \*name（为什么cout＜＜name；不是地址而是字符串)
weixin_44831176的博客
08-22 646
char *const name和const char *name（为什么cout<<name;不是地址而是字符串) //C++11标准以后 char *const name = "abcd"; 或者char *p = "abcd";是会出现warning的。 //因为"abcd"是字面量是不可改的常量，而指针却不是const *char; char a[10] = "abcd"; // 常指针：指针本身为常量，数据可改。 char *
const，成员函数的参数为指针
qq_55359819的博客
01-04 449
当参数为指针时，char* name因为是指针，所以需要写为const char* name，也就是写为常量变量，以保证参数所指向的变量不会被外部改变。
C语言 结构体
weixin_55925635的博客
08-05 956
基本数据类型 (内置类型) 原来就有 如：int double char 等等而结构体类型 —> 自定义类型设计一个结构体类型struct 类型名字{成员列表（属性）}；//名字 成员列表：可以为各种类型，如int double 结构体int age;//年龄int score;//分数};// 注意要以分号结尾类型(struct Student) + 变量名称 (stu).......................................
C++使用const定义常变量指针
LUjh_的博客
03-14 287
定义指向字符的常变量指针，并让其指向字符串"abc"，然后将'a'修改为'z'，并输出字符串 提示： 1、语句char * name ＝”abc”定义了常量字符串”abc”，类型是string literal，直接赋给char*类型的指针变量name有类型转换问题，C++11版本不进行隐含类型转换，并会告警。可以改为char * name ＝(char*)”abc”。 2、这样定义的字符串是常量，不允许修改。所以可改为： char* const name=new char[4]{'a','b','c'};
c++基础语法&demo.pdf
02-20
c c++基础语法&demo.pdfc++基础语法&demo.pdf
c++基础语法
05-08
很全的c++语法，入门级资料，简单易懂，快来看吧！！！
复习了C、C++的基础语法.zip
06-25
这次复习的资料是"复习了C、C++的基础语法.zip"，其中包含了关于C语言和C++语言的基础知识。C语言是C++的前身，它以简洁高效著称，而C++则在其基础上引入了面向对象编程的概念，增强了语言的功能。 C语言的基础语法...
C语言，C++基础知识总结
03-27
### C++基础知识 1. **面向对象编程**：C++引入了类（class）的概念，实现了封装、继承和多态，是面向对象编程的重要特征。类是创建对象的蓝图，对象则是类的实例。 2. **构造函数与析构函数**：构造函数在对象...
学完C语言基础语法之后，下一步如何提升
01-20
在掌握C语言基础语法后，进一步提升编程技能的关键在于实践和深入理解。C语言作为一门基础且强大的编程语言，它的核心在于对计算机底层操作的直接控制，因此，深入理解和运用C语言能为开发者打下坚实的编程基础。 ...
char** name是什么，如何初始化
wusecaiyun的专栏
10-09 4357
指向指针的指针，类似二维数组但不是。 用于指向不限个数、不限长度的字符串的组合。 比如[张三,李四,王五, 爱新觉罗]名字数量可以不限，名字长度可以不限。 C中常用，而C++不常用 char **names=(char **)malloc(sizeof(char*)*20); //初始化为保存20个名字 names[0]="张三"; names[1]="李四"; names[2]="
c++学习笔记
renbaifen的博客
03-08 106
指针作为函数参数： （可以实现数值的交换） #include&lt;iostream&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; using namespace std; int main() { void swap(int *p1,int *p2); int *pointer_1,*pointer_2,a,b; ...
C++基础知识点
m0_63593482的博客
11-09 72
C++基础
c++基础四 （联合体——文件）
qq_45303986的博客
06-11 1933
注意：联合体公用一个地址，所以数据类型不能带有构造函数的抽象数据 定义： 联合体的初始化： 联合体的赋值： 联合体内存占用： 联合体把变量存放到同一段存储单元 联合体可以和结构体相互嵌套： 详细请看：大小端模式_百度百科 (baidu.com) 来个例题：题目来自：unsigned int a= 0x1234; unsign_腾讯笔试题_牛客网 (nowcoder.com) 结构体的定义 ： 结构体初始化:
C++this指针
Cchengyoyoy的博客
08-25 2678
C++this指针 this是C++中的一个关键字，也是一个const指针，它指向当前对象，通过它可以访问当前对象的所有成员。 例如： class A{ private: char name; public: void show(){cout<<"hello world~"<<endl;}; void setName(char *name){th...
c++之const
风不知从何处起的小屋
01-05 213
通过const来进行常量的声明。 const的作用与#define的作用类似，但const消除了#define的不安全性。 const可以与指针一起使用，一般分为三种：指向常量的指针、常指针和指向常量的常指针。 指向常量的指针 是指一个指向常量的指针变量。 如：const char *name =“chen”; 声明一个名为name的指针变量，它指向一个字符型常量，初始化name为指向字符串“ch...
C/C+++服务器之libuv的使用实战
最新发布
小星AI
07-08 918
C/C++服务器基础
学完c++基础语法还能学什么
09-23
学完C语言基础语法之后，还可以继续学习C语言的高级语法和相关的编程技巧。一方面，可以深入学习C语言的指针和内存管理，这是C语言的重要特性之一，能够更加灵活地利用内存，提高程序的效率和性能。另一方面，可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值