百度360必应搜狗淘宝本站头条
python判断字典是否为空crontab每周一执行aes和des区别安装指定版本npmadb pull
当前位置：网站首页 > IT知识 > 正文

C语言中字符串与指针的详细使用（c语言字符指针定义字符串）

liuian 2025-07-07 20:09 42 浏览

指针变量与其指向内存的关系

指针变量也是一种变量，占有内存空间，用来保存内存地址测试指针变量占有内存空间大小。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0101()
{
    char* p = NULL;
    char buf[] = "abcde";

    printf("p1=%d\n", p);
    //改变指针变量的值
    p = buf;
    printf("p2=%d\n", p);

    //指针变量和它指向的内存块是两个不同的概念
    p = p + 1;//改变指针变量的值，即改变了指针的指向
    printf("p3=%d\n", p);
    printf("buf=%s\n", buf);

    printf("*p=%c\n", *p);//b

    printf(" 改变指针指向的内存，并不会改变指针的值\n");
    buf[1] = '1';
    printf("p4=%d\n", p);
    printf("buf2=%s\n", buf);
  
    *p = 'm';
    printf("p5=%d\n", p);
    printf("buf3=%s\n", buf);
    //写内存时，一定要确保内存可写
    //char* buf2 = "aaawwweee";//该字符串在文字常量区 不可修改
    //buf2[2] = '1';//err
    char buf3[] = "wwweerrr";
    buf3[1] = 's';//ok
    //不允许向NULL和未知非法地址拷贝内存。
    char* p3 = NULL;//err
    //char* p3 = 0x1111;//err
    //给p3指向的内存中拷贝字符串
    p3 = buf3;//ok
    strcpy(p3, "123");
    return 0;
}

修改指针变量的结果

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0201()
{
    char* p = NULL;
    char* q = NULL;



    char buf[100] = "asdzcx";

    p = &buf[0];
    printf("p=%d,%c\n", p,*p);

    p = &buf[1];
    printf("p2=%d,%c\n", p, *p);
    printf("\n");

    for (int i = 0; i < strlen(buf); i++)
    {
        p = &buf[i];
        printf("p3=%d,%c\n", p, *p);
    }
    q = (char*)malloc(100);
    if (q == NULL)
    {
        return -1;
    }
    strcpy(q, "qqqwww");
    for (int i = 0; i < strlen(q); i++)
    {
        p = q + i;
        printf("%c\n", *p);
    }
    return 0;
}

3.通过指针间接复赋值

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int get_a()
{
    int a = 10;
    return a;
}

void get_a2(int b)
{
     b = 20;
}
void get_a3(int* p)
{
    *p = 20;//通过*操作内存
}
void get_a4(int* a1, int* a2, int* a3, int* a4)
{
    *a1 = 1;
    *a2 = 2;
    *a3 = 3;
    *a4 = 4;
}

int main0301()
{
    int a = 100;
    int* p = NULL;

    //建立关系
    //指针指向谁，就将谁的地址赋值给指针
    p = &a;
    //通过*操作内存
    *p = 22;

    /*
    通过指针间接赋值
    1.两个变量
    2.建立关系
    3.通过*操作内存
    */

    int b = get_a();
    printf("b===%d\n", b);

    get_a2(b);
    printf("b2===%d\n", b);

    //如果想通过形参改变实参的值，必须地址传递
    get_a3(&b);//函数调用时建立关系
    printf("b3===%d\n", b);

    int a1, a2, a3, a4;
    get_a4(&a1,&a2,&a3,&a4);
    printf("a1=%d,a2=%d,a3=%d,a4=%d", a1, a2, a3, a4);


    return 0;
}



static void fun2(int* p)
{
    p = 0xaabb;
    printf("fun2:p=%p\n", p);
}

static void fun3(int** p)
{
    *p = 0xaabb;
    printf("fun3:p=%p\n", *p);
}
int main0302()
{
    //一个变量，应该定义一个怎样类型的指针来保存它的地址
    //在原来的基础上加一个*
    //int a = 10;
    //int* p = &a;
    //int** q = &p;

    //int********* t = NULL;
    //int********** t2 = &t;

    int* p = 0x1122;
    printf("p1=%p\n", p);

    fun2(p);//值传递
    printf("p2=%p\n", p);

    fun3(&p);//值传递
    printf("p3=%p\n", p);
    return 0;
}

4.指针作为函数参数的输入输出特性

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int get_a()
{
    int a = 10;
    return a;
}

void get_a2(int b)
{
     b = 20;
}
void get_a3(int* p)
{
    *p = 20;//通过*操作内存
}
void get_a4(int* a1, int* a2, int* a3, int* a4)
{
    *a1 = 1;
    *a2 = 2;
    *a3 = 3;
    *a4 = 4;
}

int main0301()
{
    int a = 100;
    int* p = NULL;

    //建立关系
    //指针指向谁，就将谁的地址赋值给指针
    p = &a;
    //通过*操作内存
    *p = 22;

    /*
    通过指针间接赋值
    1.两个变量
    2.建立关系
    3.通过*操作内存
    */

    int b = get_a();
    printf("b===%d\n", b);

    get_a2(b);
    printf("b2===%d\n", b);

    //如果想通过形参改变实参的值，必须地址传递
    get_a3(&b);//函数调用时建立关系
    printf("b3===%d\n", b);

    int a1, a2, a3, a4;
    get_a4(&a1,&a2,&a3,&a4);
    printf("a1=%d,a2=%d,a3=%d,a4=%d", a1, a2, a3, a4);


    return 0;
}



static void fun2(int* p)
{
    p = 0xaabb;
    printf("fun2:p=%p\n", p);
}

static void fun3(int** p)
{
    *p = 0xaabb;
    printf("fun3:p=%p\n", *p);
}
int main0302()
{
    //一个变量，应该定义一个怎样类型的指针来保存它的地址
    //在原来的基础上加一个*
    //int a = 10;
    //int* p = &a;
    //int** q = &p;

    //int********* t = NULL;
    //int********** t2 = &t;

    int* p = 0x1122;
    printf("p1=%p\n", p);

    fun2(p);//值传递
    printf("p2=%p\n", p);

    fun3(&p);//值传递
    printf("p3=%p\n", p);

    return 0;
}

5.字符串初始化

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


/*
C语言没有字符串类型，而是通过字符数组模拟
C语言字符串以字符'\0'即数字0结尾
*/

int main0501()
{
    //不指定长度，没有结束符0，有多少个元素就有多长
    char buf[] = { 'a','b','c' };//3个元素
    printf("buf=%s\n", buf);//不加\0的话 末尾乱码

    //指定长度，后面没有赋值的元素位置，自动补0
    char buf1[100]= { 'a','b','c' };
    printf("buf2=%s\n", buf1);

    //所谓元素都赋值为0
    char buf3[100] = { 0 };

    //char buf4[2] = { '1','2','3' };//err 数组越界 

    char buf5[50] = { '1','a','b','0','7' };
    printf("buf5=%s\n", buf5);

    char buf6[50] = { '1','a','b',0,'7' };
    printf("buf6=%s\n", buf6);//   1ab 

    char buf7[50] = { '1','a','b','\0','7' };
    printf("buf7=%s\n", buf7);//   1ab

    //使用字符串初始化，常用此类方式
    char buf8[] = "qaaasss";
    //strlen：测字符串长度，但不包含数字0与字符'\0'
    //sizeof：测数组长度，包含数字0和字符'\0'
    printf("strlen=%d,sizeof=%d\n", strlen(buf8), sizeof(buf8));//7   8

    char buf9[100] = "qaaasss";
    printf("strlen=%d,sizeof=%d\n", strlen(buf9), sizeof(buf9));//7  100

    printf("test");
    //  \012相当于\n
    char str[] = "\0129";
    printf("%s\n", str);




    return 0;
}


int main0502()
{
    char buf[] = "aaazzzzssssdddd";
    char* p = NULL;
    //[]方式
    for (int i = 0; i < strlen(buf); i++)
    {
        printf("%c", buf[i]);
    }
    printf("\n");


    //指针法
    //数组名字，是数组首元素地址
    p = buf;
    for (int i = 0; i < strlen(buf); i++)
    {
        printf("%c", p[i]);
    }
    printf("\n");

    for (int i = 0; i < strlen(buf); i++)
    {
        printf("%c",*(p+i));//编译器方式
    }
    printf("\n");

    for (int i = 0; i < strlen(buf); i++)
    {
        printf("%c", *(buf+i));
    }
    printf("\n");

    //buf 和 p完全等价吗
    //p++;//ok
    //buf++;//err
    //buf只是一个常量，不可修改

    return 0;
}

6.字符串拷贝

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main0601()
{
    char src[] = "qqqqqqqqqq";
    char dst[100] = { 0 };
    int i = 0;
	for (; src[i] != 0; i++)
    {
        dst[i] = src[i];
    }
    //补齐结束符
    dst[i] = 0;
    printf("%s", dst);
    return 0;
}




void my_strcpy(char* dst, char* src)
{ 
    int i = 0;
    for (; *(src+i) != 0; i++)
    {
        *(dst+i) = *(src+i);//dst[i]=src[i]
    }
   // dst[i] = 0;
    *(dst + i) = 0;
}


void my_strcpy2(char* dst, char* src)
{
    while (*src!=0)
    {
        *dst = *src;
        src++;
        dst++;
    }
    *dst = 0;
}


void my_strcpy3(char* dst, char* src)
{
    //*dst=*src
    //dst++,src++
    //判断*dst是否为0，为0跳出循环
    while (*dst++ = *src++)
    {     
        NULL;//先执行，再自加;先*dst=*src,dst++,src++
    }
}

//成功返回0，失败返回非零
//1.判断形参指针是否为NULL
//2.不要直接使用形参  以防止将形参的指针指向末尾
int my_strcpy4(char* dst, char* src)
{
    if (dst == NULL || src == NULL)
    {
        return -1;
    }
    
    //使用辅助变量将形参的值接来
    char* to = dst;
    char* from = src;

    //*dst=*src
    //dst++,src++
    //判断*dst是否为0，为0跳出循环
    while (*from++ = *to++)
    {
        NULL;//先执行，再自加;先*dst=*src,dst++,src++
    }
    printf("my_strcpy4:dst=%s\n", dst);

    return 0;
}
int mai0602n()
{
    char src[] = "qqqqqqqqqq";
    char dst[100] = { 0 };
    int ret = 0;

	ret = my_strcpy4(dst, src);
    if (ret != 0)
    {
        printf("my_strcpy4 err:%d\n", ret);
        return ret;
    }
    printf("%s\n", dst);

    int i = 0;
    int n = i++;
    printf("n=%d,i=%d\n", n, i);
    return 0;
}

7.strstr中的while与do-while的模型

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>


int main01()
{
    char* p = "sadzxaaadaszxaaaass---zxaa231312zxaa4";//zxaa
    int n = 0;
    do
    {
        p = strstr(p, "zxaa");
        if (p != NULL)
        {
            n++;//累计个数

            //重新设置查找起点
            p = p + strlen("zxaa");

        }
        else//若没有匹配的字符串跳出循环
        {
            break;
        }
    } while (*p!=0);//如果没到结尾

    printf("n=%d\n", n);

    return 0;
}


int main02()
{
    char* p = "sadzxaaadaszxaaaass---zxaa231312zxaa4";//zxaa
    int n = 0;

    while ((p = strstr(p, "zxaa")) != NULL)
    {
        //能进循环一定有匹配到子串

        //重新设置起点位置
        p = p + strlen("zxaa");
        n++;
        if (*p == 0)//如果到结束符
        {
            break;
        }
    }
    printf("n=%d\n", n);
    return 0;
}


int my_strstr(char* p, int* n)
{
    //两个辅助变量
    int i = 0;
    char* temp = p;

    while ((temp = strstr(temp, "zxaa")) != NULL)
    {
        //能进循环一定有匹配到子串

        //重新设置起点位置
        temp = temp + strlen("zxaa");
        i++;
        if (*temp == 0)//如果到结束符
        {
            break;
        }
    }
    *n = i;
    return 0;
}

int main07()
{
    char* p = "sadzxaaadaszxaaaass---zxaa231312zxaa4";//zxaa
    int n = 0;
    int ret = 0;
    
    ret = my_strstr(p, &n);
    if (ret != 0)
    {
        return ret;
    }
    printf("n=%d\n", n);
    return 0;
}

相关推荐

Python中的列表详解及示例_python列表讲解

艾瑞巴蒂干货来了，数据列表，骚话没有直接来吧列表(List)是Python中最基本、最常用的数据结构之一，它是一个有序的可变集合，可以包含任意类型的元素。列表的基本特性有序集合：元素按插入顺序存储可变...

PowerShell一次性替换多个文件的名称

告别繁琐的文件重命名，使用PowerShell语言批量修改文件夹中的文件名，让您轻松完成重命名任务在日常工作中，我们经常需要对大量文件进行重命名，以便更好地管理和组织。之前，我们曾介绍过使用Pytho...

小白必看!Python 六大数据类型增删改查秘籍，附超详细代码解析

在Python中，数据类型可分为可变类型（如列表、字典、集合）和不可变类型（如字符串、元组、数值）。下面针对不同数据类型详细讲解其增删改查操作，并给出代码示例、输出结果及分析总结。1.列表（Li...

python数据容器之列表、元组、字符串

数据容器分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）list#字面量[元素1，元素2，元素3，……]#定义变量变量名称=[元素1，元素...

python列表(List)必会的13个核心技巧(附实用方法)

列表（List）是Python入门的关键步骤，因为它是编程中最常用的数据结构之一。以下是高效掌握列表的核心技巧和实用方法：一、理解列表的本质可变有序集合：可随时修改内容，保持元素顺序混合类型：一个列表...

如何利用python批量修改文件名_python如何对文件进行批量命名

很多语言都可以做到批量修改文件名，今天我就给大家接受一下Python的方法，首选上需求。图片中有10个txt文件，现在我需要在这些文件名的前面全部加一个“学生”，可以吗？见证奇迹的时刻到了。我是怎么做...

Python中使用re模块实现正则表达式的替换字符串操作

#编程语言#我是"学海无涯自学不惜！"，关注我，一同学习简单易懂的Python编程。0基础学python（83）Python中，导入re模块后还可以进行字符串的替换操作，就是sub()...

python列表十大常见问题，你遇到第几个?

Python列表常见问题及解决方案1.修改列表时的常见陷阱问题：在遍历时修改列表#错误做法：在遍历时删除元素会导致意外结果numbers=[1,2,3,4,5,6]forn...

python入门007:编辑列表_python列表怎么写入文件

一、列表的编辑操作列表创建后，随着程序的运行，可以通过对列表元素的增删改操作来编辑列表。1、修改列表元素的值修改列表元素的操作方法与访问列表元素的方法类似。例如，要修改列表元素的值，先指定列表及元素...

Python教程:在python中修改元组详解

欢迎你来到站长在线的站长学堂学习Python知识，本文学习的是《在Python中修改元组详解》。本知识点主要内容有：在Python中直接使用赋值运算符“=”给元组重新赋值、在Python中使用加赋值运...

Python列表(List)一文全掌握:核心知识点+20实战练习题

Python列表（List）知识点教程一、列表的定义与特性定义：列表是可变的有序集合，用方括号[]定义，元素用逗号分隔。list1=[1,"apple",3.14]lis...

Python教程-列表复制_python对列表进行复制

作为软件开发者，我们总是努力编写干净、简洁、高效的代码。Python列表是一种多功能的数据结构，它允许你存储一个项目的集合。在Python中，列表是可变的，这意味着你可以在创建一个列表后改变它的...

Python入门学习教程:第 6 章 列表

6.1什么是列表？在Python中，列表（List）是一种用于存储多个元素的有序集合，它是最常用的数据结构之一。列表中的元素可以是不同的数据类型，如整数、字符串、浮点数，甚至可以是另一个列表。列...

Python列表、元组、字典和集合_python中的列表元组和字典

Python中的列表（List）、元组（Tuple）、字典（Dict）和集合（Set）是四种最常用的核心数据结构。掌握它们的基础操作只是第一步，真正发挥威力的是那些高级用法和技巧。首先我们先看一下这...

学习编程第167天 python编程 使用format方法灵活替换字符串

今天学习的是刘金玉老师零基础Python教程第51期，主要内容是python编程使用format方法灵活替换字符串。一、format方法（一）format方法是字符串自带的方法,使用的format方法...

一周热门
最近发表
标签列表