《C程序设计语言》学习笔记（05）指针与数组

最新推荐文章于 2023-03-11 16:56:45 发布
最新推荐文章于 2023-03-11 16:56:45 发布
阅读量225 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言 指针 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34337520/article/details/111717165
版权

目录

第5章 指针与数组

 
指针：保存变量地址的变量

5.1 指针与地址

  • 一个字节 - 存char
  • 两个字节 - 存 short
  • 四个字节 - 存 long，int

地址运算符 &：去一个内存对象的地址。

间接寻址（引用）运算符 *：作用于指针时，将访问指针所指向的对象。

// 声明：
double *p, atof(char *); 
// *p 指向 double 类型的指针
// 指向 char 类型的指针

  1. 每个指针都必须指向某种特定的数据类型

  2. 指针改变对象的值

  3. 指针直接使用

    int *p, x=1;
p = &x;  // 1.指针p 指向 x
*p = 0;  // 2.指针p 改变对象 x 的值
int *q;
q = p;  // 3.指针q也指向p 所指向的对象

     

5.2 指针与函数参数【将输入的下一个整型数赋值给 *pn】

指针参数使被调函数能够访问和修改主调函数中对象的值。（址传递）

swap(&a, &b)

void swap(int *px, int *py)
{
    int temp;
    temp = *px;
    *px = *py;
    *py = temp;
}

/* getint(int *) 将输入的下一个整型数赋值给 *pn */
#include <stdio.h>
#include <ctype.h>

int getch(void); //读下一个字符
void ungetch(int); //字符放回输入中

// 将输入的下一个整型数赋值给 *pn
int getint(int *pn)
{
    int c, sign;
    while(isspace(c = getch()))
        ;
    if(!isdigit(c) && c != EOF && c != '+' && c != '-')
    {
        ungetch(c);         // 输入不是数字时，返回0
        return 0;
    }
    sign = (c == '-')?-1 : 1; // sign 存正负号
    if(c == '+' || c == '-') //若有正负号，继续读下一个
        c = getch();
    for(*pn = 0; isdigit(c); c = getch()) // 是数字，则给到 *pn
        *pn = 10 * *pn + (c - '0');
    *pn *= sign;             // 最后加上正负
    if(c != EOF)
        ungetch();           // 若最后读入不是 EOF，则写回
    return c;
}

 

5.3 指针与数组

指针比数组下标编写的程序执行速度快。

数组名代表数组最开始的一个元素地址。不是变量，不可以进行数值运算。a=pa 和 a++ 非法

int *pa, a[10];
pa = a; //指针pa指向 a[0]
// 由于数组名代表数组第一个元素的地址，等价 pa=&a[0];

a[i] -> *(a+i) -> *(pa+i) -> pa[i] //等价

函数定义时，func(char s[]) 和 func(char *s) 等价。
 

5.4 地址算数运算【字符串长度】

有效的指针运算包括：

  1. 相同类型指针之间赋值运算；

  2. 指针同整数之间的加减运算；

    p+n 表示p指向的对象之后第n个对象的地址，如果int类型占4个字节，则n按4的倍数计算。

  3. 指向相同数组元素的指针间减法或比较运算；

  4. 将指针赋值为0或指针与0之间比较运算。

其他形式的指针运算都非法，例如

  • 指针间加法、乘法、除法、移位或屏蔽运算；
  • 指针同 float 或 double 类型之间的加法运算；
  • 不经强制类型转换，不同类型指针之间赋值运算。（void * 类型除外）
/* 返回字符串长度：strlen */
int strlen(char *s)
{
    char *p = s;
    while(p != '\0')
        p++;
    return  p-s;
}

 

5.5 字符指针与函数【字符串复制比较】

char amsg[] = "now is the time"; //定义一维数组

  • amsg 是仅足以存放字符串以及’\0’的一维数组；
  • 单个字符可修改，如：amsg[2]=‘b’;
  • amsg 始终指向同一存储位置。

char pmsg[] ="now is the time"; //定义指向字符串常量的指针

  • 不能改字符串内容；
  • 可修改指向其他地址。
/* 字符串复制 */
// 版本1：数组下标
void strcpy(char *s, char *t)
{
    int i;
    i = 0;
    while((s[i] = t[i]) != '\0')
        i++;
}

// 版本2：指针实现
void strcpy(char *s, char *t)
{
    while((*s++ = *t++) != '\0')
        ;
}

// 版本3：优化
void strcpy(char *s, char *t)
{
    while(*s++ = *t++) // 表达式同'\0'的比较是多余的，只需判断表达式值是否为0即可
        ;
}

/* 字符串比较 */
// 版本1：数组下标
int strcmp(char *s, char *t)
{
    int i;
    for(i=0; s[i] == t[i]; ++i)
        if(s[i] == '\0') //默认s,t 长度相等
            return 0;
    return s[i] - t[i];
}

// 版本2：指针方式
int strcmp(char *s, char *t)
{
    for(; *s == *t; s++, t++)
        if(*s == '\0')
            return 0;
    return *s - *t;
}

*p++ = val; //入栈

val = *–p; //出栈
 

5.6 指针数组以及指向指针的指针【文本排序、快速排序】

  • 读取所有输入行；
  • 对文本行进行排序；
  • 按次序打印文本行。

指针数组的声明：char *lineptr[MAXLINES];

/* 对输入的文本进行排序：readlines, writelines, qsort, getline, *alloc, afree */
#include <stdio.h>
#include <string.h>

#define MAXLINES 5000 //最大文本行

char *lineptr[MAXLINES]; //指向文本行的指针数组

int readlines(char *lineptr[], int nlines);
void writelines(char *lineptr[], int nlines);

void qsort(char *lineptr[], int left, int right);

int main()
{
    int nlines; //读取输入行数目
    if((nlines = readlines(lineptr, MAXLINES)) >= 0) // 读取输入行数，如果大于0
    {
        qsort(lineptr, 1, nlines-1); //排序
        writelines(lineptr, nlines); //输出
        return 0;
    }
    else
    {
        printf("error: input too big to sort\n");
        return 1;
    }
    return 0;
}

#define MAXLEN 1000
int getLine(char *, int);
char *alloc(int);

/* 读取输入行 */
int readlines(char *lineptr[], int maxlines)
{
    int len, nlines;
    char *p, line[MAXLEN];
    nlines = 0;
    while((len = getLine(line, MAXLEN)) > 0)
    {
        if(nlines >= maxlines || (p = alloc(len)) == NULL)
            return -1;
        else
        {
            line[len-1] = '\0';
            strcpy(p, line);
            lineptr[nlines++] = p;
        }
    }
    return nlines;
}

/* 将行保存到 s 中，并返回该行的长度*/
int getLine(char s[], int lim)
{
    int c, i;
    i = 0;
    while(--lim > 0 && (c=getchar()) != EOF && c != '\n')
       s[i++] = c;
    if(c == '\n')
        s[i++] = '\n';
    s[i] = '\0';
    return i;
}

#define ALLOCSIZE 1000
static char allocbuf[ALLOCSIZE];
static char *allocp = allocbuf;

char *alloc(int n)
{
    if(allocbuf + ALLOCSIZE - allocp >= n)
    {
        allocp += n;
        return allocp - n;
    }
    else
        return 0;
}
void afree(char *p)
{
    if(p >= allocbuf && p < allocbuf + ALLOCSIZE)
        allocp = p;
}

/* 写输出行 */
void writelines(char *lineptr[], int nlines)
{
    int i;
    for(i=0; i<nlines; i++)
        printf("%s\n", lineptr[i]);
}


// 版本2：文本行排序，数组元素是字符串，v[left]... v[right]
void qsort(char *v[], int left, int right)
{
    int i, last;
    void swap(char *v[], int i, int j);
    if(left >= right)       // 左右下标碰到，排序结束
        return;
    swap(v, left, (left+right)/2);  // 把 mid 拿到最前面，作为比较的参照物
    last = left;                    // last 移动到v[0]
    for(i = left+1; i<=right; ++i) // 遍历从 left+1 到 right
        if(strcmp(v[i], v[left]) < 0)
            // 小于v[left]的元素交换到第二个元素位置，并往后推移
            swap(v, ++last, i);
    swap(v, left, last);            // 交换left, last，如此v[last]固定位置
    qsort(v, left, last-1);
    qsort(v, last+1, right);
}

void swap(char *v[], int i, int j)
{
    char *temp;
    temp = v[i];
    v[i] = v[j];
    v[j] = temp;
}


 
快速排序：qsort (版本2)文本行

// 版本2：文本行排序，数组元素是字符串，v[left]... v[right]
void qsort(char *v[], int left, int right)
{
    int i, last;
    void swap(int *v[], int i, int j);
    if(left >= right)       // 左右下标碰到，排序结束
        return;
    swap(v, left, (left+right)/2);  // 把 mid 拿到最前面，作为比较的参照物
    last = left;                    // last 移动到v[0]
    for(i = left+1; i<=right; ++i) // 遍历从 left+1 到 right
        if(strcmp(v[i], v[left]) < 0)
            // 小于v[left]的元素交换到第二个元素位置，并往后推移
            swap(v, ++last, i);
    swap(v, left, last);            // 交换left, last，如此v[last]固定位置
    qsort(v, left, last-1);
    qsort(v, last+1, right);
}

void swap(int *v[], int i, int j)
{
    char *temp;
    temp = v[i];
    v[i] = v[j];
    v[j] = temp;
}

 

5.7 多维数组【日期转第几天】

日期转某年中第几天、某年第几天转某月某日：day_of_year, month_day

#include <stdio.h>

static char daytab[2][13] =
{
    {0,31,28,31,30,31,30,31,31,30,31,30,31},
    {0,31,29,31,30,31,30,31,31,30,31,30,31}
};
/* 日期转某年中第几天 */
int day_of_year(int year, int month, int day)
{
    int i, leap;
    leap = (year%4==0 && year%100!=0) || year%400==0; //判断闰年
    for(i=1; i<month; i++)
        day += daytab[leap][i];
    return day;
}
/* 某年第几天转某月某日 */
void month_day(int year, int yearday, int *pmonth, int *pday)
{
    int i, leap;
    leap = (year%4==0 && year%100!=0) || year%400==0;
    for(i=1; yearday>daytab[leap][i]; i++)
        yearday -= daytab[leap][i];
    *pmonth = i;            // 传指针是为了直接改变
    *pday = yearday;
}

int main()
{
    int year, month, day;
    printf("请输入年月日: ");
    scanf("%d %d %d", &year, &month, &day);
    printf("这天是该年的第%d天\n", day_of_year(year, month, day));
    return 0;
}

 

5.8 指针数组的初始化

static char *name[] = 
{
  "Illegal month",
  "January","February","March","April","May","June","July","August","September","October","November","December"
};

 

5.9 指针与多维数组

int a[10][20]; //二维数组，分配了200个 int 类型长度的存储空间
int *b[10]; //指针数组，每行长度可以不同

 

5.10 命令行参数

  • argc：参数计数，表示命令行参数的个数。
  • *argv[]：参数向量，指向字符串数组的指针。

argc 至少为1，argv[0] 值为启动该程序的程序名。

argv[argc] 的值必须为一个指针。

#include <stdio.h>

/* 回显程序命令行参数 版本1 */
int main(int argc, char *argv[])
{
   int i;
   for(i=1; i<argc; i++)
   {
       printf("%s%s", argv[i], (i<argc-1)? " " : "");
   }
   printf("\n");
   return 0;
}

#include <stdio.h>

/* 回显程序命令行参数 版本2 */
int main(int argc, char *argv[])
{
    while(--argc > 0)
       printf("%s%s", *++argv, (argc > 1)? " " : "");
   printf("\n");
   return 0;
}

参数命令行程序的运行方案：

  1. 找到可执行文件 .exe 的位置，复制路径（建议放在桌面）
  2. 打开cmd，输入： cd C:\Users\Administrator\Desktop\000temp_test\bin\Debug
  3. 000temp_test.exe hello, world
  4. 输出： hello, world

打印与第一个参数指定的模式匹配的行

#include <stdio.h>
#include <string.h>
#define MAXLINE 1000

int getLine(char *line, int max);

int main(int argc, char *argv[])
{
    char line[MAXLINE];
    int found = 0;
    if(argc != 2)
        printf("Usage: find pattern\n");
    else
        while(getLine(line, MAXLINE) > 0)
        {
            if(strstr(line, argv[1] != NULL))
            {
                printf("%s", line);
                found++;
            }
        }
    return found;
}

/* 将行保存到 s 中，并返回该行的长度*/
int getLine(char *s, int lim)
{
    int c, i;
    i = 0;
    while(--lim > 0 && (c=getchar()) != EOF && c != '\n')
       s[i++] = c;
    if(c == '\n')
        s[i++] = '\n';
    s[i] = '\0';
    return i;
}

标准库函数 strstr(s, t) 返回一个指针，指向字符串 t 在字符串 s 中第一次出现的位置。声明在头文件<string.h>中

 

5.11 指向函数的指针

int (*cmp)(void *, void *)

comp 是一个指向函数的指针。

具有两个 void* 类型的参数，返回值类型 int 。

 

5.12 复杂声明

int *f() // f 是一个函数，返回一个指向 int 型指针
int (*pf)() // pf是指向函数的指针，返回 int 对象
char **argv // 指向字符指针的指针
int (*daytab)[13] // 指向整型数组的指针（数组指针）
int *daytab[13] // daytab是一维数组，元素是指向 int 的指针（指针数组）
void *comp() // comp是函数，返回空指针
void (*comp)() // comp是指向函数的指针，返回空。
char (*(*x())[])() 
/*
（从内向外）
1.x是一个函数；
2.返回指针；
3.指针指向数组；
4.数组元素是指针；
5.指向函数；
6.返回 char。
*/
char (*(*x[3])())[5] 
/*
（从内向外）
1.x是拥有3个元素的数组；
2.数组元素是指针；
3.指向函数；
4.返回指针；
5.指针指向5个元素的数组；
6.数组元素是 char

2-dim 数组元素，五种引用方式：a[3][4]

  • a[i][j]
  • *(a[i]+j)
  • *(*(a+i)+j)
  • (*(a+i))[j]
  • *(&a[0][0]+4*i+j)
Cou流氓也要有文化
关注
专栏目录
单链表原地逆置
小白的博客
07-01 1万+
题目 是编写算法将带一单链表逆置，要求空间复杂度为O(1)O(1)O(1)。 分析 单链表分为带头节点和不带头节点两种，逆置思路有两种，第一种是采用头插法重新建立新的单链表，该方法直接遍历链表，每次将当前结点添加到新链表的头部；第二种是通过该表*next指针，定义三个指针*pre, *p, *r，分别表示三个连续结点，将p->next指向pre，但同时p的后继节点会断开，所以需要用r保存其后...
C语言程序设计（第4版）谭浩强著—学习笔记chapter eight 指针
m0_63640882的博客
04-12 578
第八章 指针一、指针（地址）与指针变量二、通过指针引用数组三、通过指针引用字符串 内存区的每一个字节有一个编号，这就是地址。如果程序中定义了一个变量，在对程序进行编译时，系统就会给这个变量分配内存单元。 C语言中， 对变量的访问有两种方式，直接访问和间接访问。 int a=5;//直接访问 scanf(“%d”,&a);//间接访问 C语言中，指针是存放地址的一种特殊变量。也可以把该变量的地址称为指针。 在C语言中可以定义一些特殊变量，将这些专门存放变量的地址的特殊变量称为指针变量。 指针变量的值是
Leetcode每日一题：面试题02.02.kth-node-from-end-of-list-lcci（返回倒数第k个节点）
CodeLuweir 的博客
09-28 3198
思路：典型得快慢指针问题，快指针与慢指针中间隔着k-2个节点，那么同时++快慢指针，当快指针指向链表结尾节点时，慢指针指向倒数第k个节点； struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int kthToLast(ListNode *head, int k) { ListNode *left = head, *right = head; int count = 1; .
单链表的原地逆置
I_still_like_you的博客
05-06 1590
单链表的原地逆置
C语言程序设计谭浩强重点笔记.pdf
05-25
谭浩强教授的《C语言程序设计》是学习C语言的经典教材之一，其重点笔记内容涵盖了C语言的方方面面，从基础知识到高级应用都有详尽的介绍。下面我将结合文档内容对C语言的关键知识点进行详细介绍。 ### 第一章 C语言...
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
学习这两门语言，你需要通过实践编写小程序来巩固理论知识，逐步掌握程序设计的思想和技巧。《C语言和C++Builder学习笔记.docx》这份文档可能包含了作者在学习过程中的心得、示例代码和解决问题的经验，对于初学者来...
高级语言程序设计学习笔记-C语言
最新发布
04-16
3. **指针**：深入学习指针的概念，如何声明、初始化和操作指针，以及指针与数组、函数的关系。 4. **内存管理**：学习动态内存分配（malloc、calloc、realloc、free）以及如何避免内存泄漏。 5. **文件操作**：...
C语言程序设计谭浩强重点笔记.zip
03-05
本压缩包“C语言程序设计谭浩强重点笔记.zip”包含了一份详尽的C语言学习笔记，以文档形式提供，名为“C语言程序设计谭浩强重点笔记.doc”。这份笔记是对谭浩强教授书中的关键概念、语法和编程技巧的提炼，对于深入...
55-将单链表原地逆置（三种方法）
LINZEYU666的博客
11-28 5441
void Reverse(HeadList *head) { if(head==NULL||head->next==NULL||head->next->next==NULL) return ; HeadList *s=NULL; HeadList *p=head->next; HeadList *q=p->next; while(p!=NULL) { p->next=s; s=p; p=q; if(q!=NULL) { q=q-&.
单链表的就地逆置
热门推荐
赞美月亮的专栏
11-07 9万+
单链表的就地逆置是指辅助空间O(1)的逆置方法，有两种方法：普通循环（头插法重新建立带头节点的新链表）和递归。下面我们详细介绍这两种方法：方法一：头插法算法思想：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。void converse(LinkList *head) { Lin...
C语言之struct 和 typedef struct
scottar的博客
10-07 1964
struct 用法 struct tag { member-list member-list member-list ... } variable-list ; 实例 struct Books { int book_id; char *bookname; } 说明： （1）上面声明了一个结构的“变量类型”，我们可以通过上面去实例化一些变量 如下： int main(){ struct Books a; a.book_id = 1; a
数据结构 -- 实现单链表的原地逆置
weixin_53461714的博客
10-04 6814
题目： 编写算法将一个带头结点单链表逆置； 分析： 通过该表的*next指针实现。 定义三个指针*p,*pre,*r，分别表示三个连续的结点； 先用p->next=NULL断掉第一个结点的后继节点，用pre表示原来单链表中p的前驱结点，再用p->next指向pre，但同时p的后继结点会断开，所以需要用r来保存其后继结点。 功能函数代码： void Reverse(linklist& L) { l...
【数据结构】单链表的原地逆置
Forever_ZhangKe的博客
04-04 758
class Solution {public:       ListNode* ReverseList(ListNode* head) {        if(head==NULL)        {            return NULL;        }         ListNode *p,*q;         p=head-&gt;next;         head-&gt;...
C++中打印字符指针的地址
kingsfar的博客
01-11 2626
问题描述： 今天无意中遇到一个问题，有如下程序，我想打印两个对象中的字符指针的地址来验证系统提供的赋值运算符重载是否是浅拷贝，结果直接cout字符指针输出的并不是指针的地址而是整个字符串，为什么呢？ #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string.h> using namespace std; class ClassA { public: ClassA() { } ClassA(
【数据结构】单链表中，如何实现 将链表中所有结点的链接方向“原地”逆转
m0_71071692的博客
03-11 2187
如何实现：将链表中所有结点的链接方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求空间复杂度为O（1）
C语言编程基础：新版《C程序设计语言》学习笔记
"C程序设计语言（第2版·新版" 的内容主要涉及C语言的基础知识，包括C语言的语法、编程技巧以及程序设计的基本概念。 C语言是一种强大的、低级的编程语言，由丹尼斯·里奇和肯·汤普逊在贝尔实验室开发。在"第2版·...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值