解析C/C++指针、函数、结构体、共用体
目录
- 指针
- 变量与地址
- 指针与指针变量
- 占内存空间
- 指针运算
指针
变量与地址
变量给谁用的?
变量是对某一块空间的抽象命名。
变量名就是你抽象出来的某块空间的别名。
指针就是地址。指向某个地址。
指针与指针变量
指针是指向某块地址。指针(地址)是常量。
指针变量是可以发生变化的。
#include <stdio.h>
int main()
{
int i = 1;
int *p = &i;
printf("i = %d \n", i);
printf("&i = %p \n", &i);
printf(" p = %p \n", p);
printf("&p = %p \n", &p);
printf("*p = %d \n", *p);
// 为什么不用char* p = &i;
//TYPE NAME = VALUE
//int* p = &i;
//int i = 1;
}
直接访问间接访问
占内存空间
都是8字节，linux 64 位中。
空指针 野指针 空类型
int * i= NULL;
指针运算
两个指针同时指向一个数组。++ 、--、比较、关系、&、*
指针与一维数组
数组名和 指针的区别?
a是数组名字是一个表示地址的常量。
指针是一个变量。
a++;
p++;
#include <stdio.h>
int main()
{
int a[3] = {1,2,3};
int *p = a;
int i;
for(i = 0;i < sizeof(a)/sizeof(*a); i++) {
printf("%d %d %d %d \n",a[i],*(a+i),p[i],*(p+i)); // a[i]
printf("%p %p %p %p \n",a+i, &a[i],p+i, p+i); // &a[i]
}
printf("\n");
}
这里代码体现什么是指针常量什么是指针变量？
#include <stdio.h>
int main()
{
int a[3];
int i;
int *p = a;
for(i = 0;i < sizeof(a)/sizeof(*a); i++) {
printf("%p -> %d\n",&a[i],a[i]);
}
for(i = 0;i <sizeof(a)/sizeof(*a); i++) {
scanf("%d",p++);
//p = a;
for(i = 0;i < sizeof(a)/sizeof(*a); i++,p++) {
printf("%p -> %d\n",p,*p);
printf("\n");
}
指针与二维数组
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[2][3] = {1,2,3,4,5,9};
int i,j;
int *p;
//(W) p = a;
//wall等号右边a是在行间跳转的指针
// 等号左边是列间跳转的指针
p = *(a+0);
//p = &a[0][0];//*(a+0),*a;
printf("%p->%p \n", a, a + 1);
// printf("%p -> %d \n\n",p,*p);
// for(i = 0; i < 6; i++,p++) {
// printf("%d ",*p);
// }
// printf("\n");
for(i = 0;i < 2; i++) {
for(j = 0; j < 3; j++) {
printf("%p->%d\n",&a[i][j],a[i][j]);
printf("%p->%d\n",*(a+i)+j,*(*(a+i)+j));
//printf("%p->%d\n",a[i]+j,*(*(a+i)+j));
//printf("%d ",a[i][j]);
}
printf("\n");
}
exit(0);
}
指针与字符数组
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 字符指针和字符数组之间的使用
//
// 练习 定义数组后定义指针 后面操作都用指针实现
int main()
{
#if 0
char* str = "hello"; // "hello" 串常量
printf("%d %d \n",sizeof(str),strlen(str));// 8 5
//strcpy(str,"world"); //err 为什么不可以？区分字符指针和字符数组的区别 :企图用"world" 覆盖串常量
str = "world";
puts(str);
#endif
char str[] = "hello";
printf("%d %d \n",sizeof(str),strlen(str));// 6 5
// (F) str = "hhhh"; // 数组名是一个地址常量怎么可能放到等号左边？？？
strcpy(str,"jjjj");
char str[] = "hello world";
char *p = str + 7;
puts(p);
exit(0);
}
const与指针
#include <stdio.h>
#include <stdlib.h>
/*
常见const
const int a;
int const a;
const int *p; // 常量指针
int const *p;
int *const p; // 指针常量
const int *const p;
define 不检查语法
*/
int main()
{
#if 0
// cosnt修饰常规变量的使用特点
// 这个警告已经构成error
const float pi = 1.14159;
// pi = 9999.2;
float *p = π // initialization discards ‘const' qualifier from pointer target type [enabled by default]
*p = 1223.333333;
// 修改方法 const float *p = π
printf("%f\n",pi); // 1223.333333
printf("%f\n",*p);
#endif
// 常量指针:指针的指向可以发生变化但是指针所指向的目标值是不能变化的
// const *p
// 值不能变
// 指向可以发生变化
int i = 1;
const int *p1 = &i;
int j = 88;
//T i= 10;
//F *p1 = 99;
//T p1 = &j;
printf("%d\n",i);
printf("%d\n",*p1);
// 指针常量:指针的指向不能发生变化，指针所指向的目标变量的值可以发生变化。
int j= 100;
int * const p1 = &i;
//T *p1 = 10;
//F p1 = &j;
//const 左右都有 指向和值都不能变
int num = 10;
const int* const p3 = #
// *p3 = 99;
// p3 = &i;
exit(0);
}
指针数组和数组指针的区别
数组指针
#include <stdio.h>
#include <stdlib.h>
/*
数组指针: [存储类型] 数据类型 (* 指针名) [下标] = 值;
int (*p)[3]; -> type name; -> int[3] *p;
*/
int main()
{
// 数组指针
int a[2][3] = {1,2,3,4,5,9};
int i,j;
int *p = *a;
int (*q)[3] = a;
//printf("%d \n", *a); // a[0][0]的地址
//printf("%d \n", **a); //1
#if 0
// printf("%d \n",*p);//q
//int *p = *a;
//printf("%d \n",*p); //q
// int (*q)[3] = a+1;
// printf("%d \n",**q); // 4
printf("\n");
for(i = 0;i < 2; i++) {
for(j = 0; j < 3; j++) {
// printf("%p->%d\n",*(a+i)+j,*(*(a+i)+j));
printf("%p->%d\n",*(q+i)+j,*(*(q+i)+j));
}
printf("\n");
}
#endif
}
指针数组：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
int *arr[3]; -> TYPE NAME; -> int *[3] arr;
*/
int main()
{
char *name[5] ={"english","math","cpp","teacher","computer"};
int i,j;
for(i = 0; i < 5; i++) {
puts(name[i]);
}
for(i = 0; i < 5 ;i++) {
int k = i;
for(j = i+1;j < 5; j++) {
if(strcmp(name[k],name[j]) > 0) {
k = j;
}
}
if(k != i) {
char *tmp = name[i];
name[i] = name[k];
name[k] = tmp;
printf("排序后：\n");
exit(0);
}
指针和函数
函数：
echo $? // 显示上个命令的返回值
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
/*
定义：
int a[N] = {1,2,3,4,5,6};
int *p = a;
-> a *a a[0] &a[3] p[i] p *p p+1
-> int* int int int * int int* int int*
*/
//void func1(int *a,int n)
void func1(int* a,int n,int *b)
{
cout << "== b =" << *b<< endl; // 1
for(int i = 0;i < n; i++)
{
printf("%d ",*(a+i));
}
printf("\n");
return ;
}
int main(int argc, char** argv) {
int arr[3] = {1,2,3};
func1(arr,3,&arr[1]);//&(*(ar+1))
return 0;
用指针与一维数组的使用：
void func2(int *p,int n)
{
int m = n / 2;
for(int i = 0;m--;i ++)
{
int j = n - i -1;
int tmp = *(p+i);
*(p+i) = *(p+j);
*(p+j) = tmp;
}
}
int main(int argc, char** argv) {
int arr[] = {1,2,3,6,4,2,38,4,2,23};
//func1(arr,3,&arr[1]);//&(*(ar+1))
func2(arr,10);
for(int i = 0;i < 10;i ++)
cout << arr[i] << ' ' ;
cout <<endl;
return 0;
函数与二维数组：
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
/*
int a[M][N] = {......};
int *p = a;
int (*q)[N] = a;
-> a[i][j] *(a+i) a[i]+j p[i] *p
int int * int * int int
-> q[i][j] *q q p+3 q+2
int int* int(*)[N] int * int (*)[N]
*/
void func(int *p,int n)
{
for(int i = 0;i < n; i++)
{
cout << *p << ' ';
p++;
}
}
void print_arr(int (*p)[3])
for(int i = 0;i < 3;i++)
for(int j = 0;j < 3;j++)
{
cout << *(*(p+i)+j) << ' ';
}
cout<< endl;
int main(int argc, char** argv) {
int arr[3][3] = {1,2,3,6,4,2,38,4,2};
func(arr[0],9); // *arr &arr[0][0] arr[0]
// 这里func(arr,9) 形参是int *p 就报错 p是一个列指针，二维数组不一样
print_arr(arr);
return 0;
案例使用二维数组传参
float average_score(int *a,int n)
{
float sum = 0.0;
for(int i = 0;i < n; i++)
{
sum += *(a+i);
}
return sum/n;
}
void find_num(int(*p)[3],int num)
{
for(int i = 0;i < 3 ;i++)
printf("%d ",*(*(p+num) + i));
cout << endl;
return ;
}
int main(int argc, char** argv) {
int arr[3][3] = {1,2,3,6,4,2,38,4,2};
float ave = 0.0;
ave = average_score(*arr,9);
printf("%f \n",ave);
find_num(arr,0);
return 0;
}
函数与指针关系的详细剖析
指针函数
返回值 * 函数名（参数）
#if 0
void find_num(int(*p)[3],int num)
{
for(int i = 0;i < 3 ;i++)
printf("%d ",*(*(p+num) + i));
cout << endl;
return ;
}
#else
int * find_num(int(*p)[3],int num)
return *(p+num);
#endif
int main(int argc, char** argv) {
int arr[3][3] = {1,2,3,6,4,2,38,4,2};
float ave = 0.0;
ave = average_score(*arr,9);
printf("%f \n",ave);
int * res;
res = find_num(arr,0);
if(res != NULL)
{
for(int i = 0;i < 3;i++)
printf("%d ",res[i]);
cout <<endl;
}
else
printf("can not find\n");
return 0;
函数指针
#include <iostream>
using namespace std;
int add(int a,int b)
{
return a+b;
}
int sub(int a,int b)
{
return a-b;
}
int main(int argc, char** argv)
{
int a = 2, b = 3;
int (*p)(int,int);
int (*q)(int,int);
int ret;
p = add;
q = sub;
printf("%d \n",p(a,b));
printf("%d \n",q(a,b));
return 0;
}
回调函数
函数指针数组
类型 （*数组名[下标]）（形参）；
#include <iostream>
using namespace std;
int add(int a,int b)
{
return a+b;
}
int sub(int a,int b)
{
return a-b;
}
int main(int argc, char** argv)
{
int a = 2, b = 3;
int (*funcp[2])(int,int);
int ret;
funcp[0] = add;
funcp[1] = sub;
for(int i = 0;i < 2; i++)
{
ret = funcp[i](a,b);
printf("%d \n",ret);
}
return 0;
}
指向指针函数的函数指针数组
数组存放指针，指针指向函数，函数返回值是指针类型。
结构体
- 产生的意义
- 类型描述
- 嵌套定义
- 定义变量、初始化及引用
- 占用内存大小
定义和使用：
#include <iostream>
using namespace std;
#define NAMESIZE 100
struct simp_st
{
int i,j;
float f;
char ch;
};
struct birthday_st
int year,month,day;
struct student_st
int id;
char name[NAMESIZE];
struct birthday_st birthday;
int math;
int chinese;
int main(int argc, char** argv)
struct student_st stu = {10011,"Alan",{3011,22,11},22,54};
struct student_st *p = &stu;
printf("%d %s %d-%d-%d %d %d \n",stu.id,stu.name,stu.birthday.year,stu.birthday.month,stu.birthday.day,stu.math,stu.chinese);
printf("%d %s %d-%d-%d %d %d \n",p->id,p->name,p->birthday.year,p->birthday.month,p->birthday.day,p->math,p->chinese);
struct student_st stu[2] = {{10011,"Alan",{3011,22,11},22,54},{10012,"salay",{2021,2,12},88,66}};
struct student_st *p = &stu[0];// &stu[0] stu
for(int i = 0;i < 2;i++,p++)
{
printf("%d %s %d-%d-%d %d %d \n",p->id,p->name,p->birthday.year,p->birthday.month,p->birthday.day,p->math,p->chinese);
}
return 0;
}
内存对齐问题
addr/sizeof()
构造类型-结构体内存问题及函数传参
为后面linux高级铺垫。
- 可以实现一个学生管理系统。
- 产生及意义
- 类型描述
- 嵌套定义
- 定义变量
- 占用内存大小
- 函数传参
- 位域
union 名{
数据类型 成员名1;
数据类型 成员名2;
}；
枚举类型
enum 名{
成员1;
成员2;
成员3;
}
到此这篇关于C/C++指针、函数、结构体、共用体的文章就介绍到这了,更多相关C++指针 函数 结构体 共用体内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
C++动态分配和撤销内存以及结构体类型作为函数参数
C++动态分配内存(new)和撤销内存(delete) 在软件开发过程中,常常需要动态地分配和撤销内存空间,例如对动态链表中结点的插入与删除.在C语言中是利用库函数malloc和free来分配和撤销内存空间的.C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函数. 注意: new和delete是运算符,不是函数,因此执行效率高. 虽然为了与C语言兼容,C++仍保留malloc和free函数,但建议用户不用malloc和free函数,而用new和delete运算
-
C++结构体作为函数参数传参的实例代码
具体代码如下所示: #include<iostream> using namespace std; #include<string> //结构体 struct Student { string name; int age; int score; }st3; /* *结构体作为函数参数传参 */ //值传递 void printStufdent1(struct Student st3) { cout << "子函数" << endl; st
-
使用pybind11封装C++结构体作为参数的函数实现步骤
python调用C/C++有不少的方法,如boost.python, swig, ctypes, pybind11等,这些方法有繁有简,而pybind11的优点是对C++ 11支持很好,API比较简单,现在我们就简单记下Pybind11的入门操作. pybind11简介 pybind11是一个轻量级的只包含头文件的库,它主要是用来在已有的 C++代码的基础上做扩展,它的语法和目标非常像Boost.Python,但Boost.Python为了兼容现有的基本所有的C++编译器而变得非常复杂和庞大,而
-
解析C/C++指针、函数、结构体、共用体
目录 指针 变量与地址 指针与指针变量 占内存空间 指针运算 指针 变量与地址 变量给谁用的?变量是对某一块空间的抽象命名.变量名就是你抽象出来的某块空间的别名.指针就是地址.指向某个地址. 指针与指针变量 指针是指向某块地址.指针(地址)是常量.指针变量是可以发生变化的. #include <stdio.h> int main() { int i = 1; int *p = &i; printf("i = %d \n", i); printf("&
-
c# 如何使用结构体实现共用体
目录 理解 C 语言的共用体 使用 C# 实现共用体 共用体作为另一个共用体的成员 在 C 和 C# 编程语言中,结构体(Struct)是值类型数据结构,它使得一个单一变量可以存储多种类型的相关数据.在 C 语言中还有一种和结构体非常类似的语法,叫共用体(Union),有时也被直译为联合或者联合体.而在 C# 中并没有共用体这样一个定义,本文将介绍如何使用 C# 实现 C 语言中的共用体. 理解 C 语言的共用体 在 C 语言中,共用体是一种特殊的数据类型,允许你使用相同的一段内存空间存储不同的
-
深入了解C++ 结构体（struct）与共用体（union）
编码运行环境:VS2017+Win32+Debug,Win32表示生成32bits的应用程序. 结构体(struct)与共用体(union)是C语言中就已经存在的数据类型,C++对他们进行了扩充,最大的变化是允许在结构和公用体中定义成员函数.下面将通过实例讲解二者的特性和用法. 1.struct 以下是一个使用了结构体的C++程序. #include <iostream> using namespace std; struct Room { int floor; int No; }; stru
-
C语言中结构体和共用体实例教程
目录 一.实验目的 二.实验内容 三.实验记录 3.1 候选人选票统计 3.2 print函数 3.3 链表 总结 一.实验目的 掌握结构体类型变量的定义和使用: 掌握结构体类型数组的概念和应用: 掌握链表的概念,初步学会对链表进行操作: 掌握共用体的概念与使用: 掌握指向结构体变量的指针. 掌握指向结构体数组的指针的应用. 二.实验内容 编写下列程序,然后上机调试运行. 对候选人得票的统计程序.设有3个候选人,每次输入一个得票的候选人的名字,要求最后输出各人得票结果. 编写一个函数print,
-
共用体的定义与应用详细解析
定义:使用覆盖技术,几个变量相互覆盖,从而使几个不同变量共占同一段内存的结构,成为共同体类型的结构. 共同体的定义类似结构体,不过共同体的所有成员都在同一段内存中存放,起始地址一样,并且同一时刻只能使用其中的一个成员变量. 声明共用体的一般形式为: 复制代码 代码如下: union 共用体类型名{ 成员列表}; 定义共用体变量的一般形式为:共用体类型名 共用体变量名;例如: 复制代码 代码如下: union data{int i;char ch;double d; }
-
C++基础入门教程（三）：数组、字符串、结构体、共用体
今天的标题取得..好严肃的感觉.(小若:咳噗) 这章的内容虽然还是很详(lao)细(dao),但已经开始有很多值得记录的内容了~ 那么,今天就来初次介绍数组与字符串-以及结构体..还有共用体..吧. 1.数组 我记得大四实习的时候,请教同事:"什么是属主?"(其实是和数据库相关的东西) 然后同事惊讶地说道:"啊,你连数组都不知道..这,基础还是要好好补补-呐,数组的意思呢,是这样的-" 我听着听着就不对劲,"等等,这是数组-其实我是问这个属主-"
-
Go语言学习函数+结构体+方法+接口
目录 1. 函数 1.1 函数返回值 同一种类型返回值 带变量名的返回值 函数中的参数传递 函数变量 1.2 匿名函数——没有函数名字的函数 在定义时调用匿名函数 将匿名函数赋值给变量 匿名函数用作回调函数 可变参数——参数数量不固定的函数形式 1.3 闭包 1.4 defer语句 处理运行时发生的错误 1.5 宕机恢复(recover)——防止程序崩溃 2. 结构体 2.1 定义与给结构体赋值 3. 方法 3.1 结构体方法 3.2 接收器 指针接收器 非指针类型接收器 4. 接口 4.1 声
-
C语言深入讲解指针与结构体的使用
目录 1 啥是指针 1.1指针与指针变量 1.2总结 2 指针和指针类型 2.1指针+-整数 3 野指针 3.1 野指针的成因 1指针未初始化 2指针越界访问 3指针指向的空间释放 3.2 如何避免野指针的出现 4 二级指针 5 指针数组 6 结构体 6.1 结构的声明 6.2 结构体变量的定义和初始化 6.3 结构体的访问 6.4 结构体传参 1 啥是指针 刚刚接触指针的同学肯定会很懵逼,指针是啥啊?指南针哈哈,不和大家开玩笑,我们进行正题吧,指针是本质是就是地址,但我们要注意我们口头上常说的
-
一文带你了解Go语言中的指针和结构体
目录 前言 指针 指针的定义 获取和修改指针所指向变量的值 结构体 结构体定义 结构体的创建方式 小结 前言 前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍,本文将对 Go 里面的指针和结构体进行介绍,也为后续文章做铺垫. 指针 在 Go 语言中,指针可以简单理解是一个地址,指针类型是依托于某一个类型而存在的,例如 Go 里面的基本数据类型 int.float64.string 等,它们所对应的指针类型为 *int.*float64.*string等. 指针的定
-
Go语言指针访问结构体的方法
本文实例讲述了Go语言指针访问结构体的方法.分享给大家供大家参考.具体分析如下: Go有指针,但是没有指针运算. 结构体字段可以通过结构体指针来访问.通过指针间接的访问是透明的. 复制代码 代码如下: package main import "fmt" type Vertex struct { X int Y int } func main() { p := Vertex{1, 2} q := &p q.X = 1e9 fmt.P