Question

C++ 代码 ABC * p; unsigned short b[4]; p = (ABC *)&b[0];

其中 ABC是一个结构体 p应该是指向ABC变量的指针 但是第三行代码说明p存的是b[0]的地址 但是p却是指向ABC变量的 这样一转换 我不知道
p里面到底是什么了

Answer 1

C语言基础知识常量和变量分类:C/C++

1.常 量: 程序执行过程中,值不变的量。 3 ，\'a\'
变 量：值可以改变的量。
一个变量有一个名字，在内存中有一定的存储单元，存放变量的值。
2.常量类型：
a.整 型：12，0，-3
b.实 型：4.6,-1.2
c.字 符 型: \'a\',\'d\'
d.符号常量: #define PRICE 30 (PRICE不能再被赋值且要大写)

3.变 量: 先定义,后使用。一个变量只能被指定为一确定类型。

4.标识符：标识变量名，符号常量名，函数名，数组名，类型名，文件名的有效字符数列。
a.由字母、数字、下划线三种字符组成，第一个字符必须为字母或下划线。
b.大写字母、小写字母被认为是两个不同的字符。
c.长度一般小于8个。

数据类型
一.整 型:
1.整型常量
a.十 进 制:12,-3,0
b.八 进 制:以0开头。
c.十六进制:以0x开头。

2.整型变量
a. int -32768——32767
b. short int -32768——32767
c. long int
d. unsigned int 0——65535
e. unsigned short 0——65535
f. unsigned long

int、short int、long int 第一位为符号位 0000001 （0为正，1为负）
unsigned 第一位不是符号位 0000001
所以int型和unsigned型的000001不是同一个值。

二.实 型：
1.实型常量：
a.十进制数：数字和小数点组成。0.12，.12，12.0，0.0
b.指 数：e之前必须有数字，e后面必须为整数。12e3

2.实型变量：
a.单精度：float 7位有效数字 111111.1可，111111.11不可。
b.双精度：double 15—16位有效数字 。

三.字符型:
1.字符常量:
a. \'a\' , \'x\' , \'*\' ,\'$\' 。
b. 转义字符：‘\\n\'换。 \'\\t\'从第九列开始。\'\\r\'回车。 \'\\b\'退一格。

2.字符变量：
char char=\'a\' 一个字符变量在内存占一个字节。

。将一个字符常量放到一个字符变量中，并不是把该字符本身放到内存单元中去，而是将该字符的ASC码
放到存储单元中，所以字符型数据和整型数据之间可以通用。一个字符型数据既可以以字符形式输出，
又可以以整数形式输出。

四.字符串常量:
"how are you", "a","&12"

。不能把一个字符串赋给一个字符变量。 char c=\'a\'对,char c="how" 错。
。\'a\' :在内存中存a。
“a”:在内存中存a\\0。
‘\\0’是C语言中判断字符串是否结束的标志。

变量赋初值
a. int a=3;
float f=7.2;
char c=\'a\';
b. int a,b,c=5;
相当于 int a,b,c;
c=5;
c. int a=3;b=3;c=3; 不可写： int a=b=c=3;

各类数值型数据间的混合运算
整型、实型、字符型数据可以混合运算：10+\'a\'+1.5-8765.4321*\'b\'
double<--float
long
unsigned
int <--char,shot

float型转晃?double型
char型,shot型转换为 int型
int型 转换为double型 等等

算术运算符和算术表达式
1.基本算术运算符
+ 加
- 减
* 乘
/ 除 5/3=1
% 摸(MOD) 5%3=2

2.强制类型转换运算符:将一个表达式转换成所需类型
(类型名)(表达式)
(double)a 将a转换为double型
(int)(x+y) 将x+y转换为int型
(float)(5%3) 将5%3转换为float型

putchar函数：输出一个字符
#include "stdio.h"
a. char a;
a=\'C\';
putchar(a);
b. putchar(\'\\n\');
c. putchar(\'\\102\');

getchar函数：输入一个字符
#include "stdio.h"
a. char c;
c=getchar();
putchar(c);
b. putchar(getchar());
c. printf("%c",getchar());

putchar函数:输出若干个任意类型的数据
a. printf("%d,%d",a,b);
b. printf("a=%d b=%d",a,b);

1.d 输出十进制整数
a. %d:
b.%md: 指定输出的宽度。数据位数小于m，左端补空格；大于m，按实际位数输出。
a=123;b=12345;
printf("%4d,%4d",a,b);
输出结果为：_123,12345
c.%ld: 输出长整型数据。
long a=123456;
printf("%ld",a); 用%d，错。
printf("%9ld",a); 输出结果为：___123456
2. o 输出八进制数
3. x 输出十六进制数
4. u 输出unsigned型数据
5. c 输出一个字符
6. s 输出一个字符串
a.%s printf("%s"."how");
b.%ms
c.%-ms
d.%m.ns
e.%-m.ns
7. f 以小数形式输出实数
a.%f
b.%m.nf
c.%-m.nf
8. e 以指数形式输出实数
a.%e
b.%m.ne
c.%-m.ne

scanf函数：输入任意类型的多个数据
scanf("%d%d%d",&a,&b,&c); &a指a在内存中的地址。
——按a,b,c在内存的地址将a,b,c的值存入。

if语句
1. if (A) B;
如果条件A满足，执行B，否则执行下一句。

2. if (A) B
else C;
如果条件A满足，执行B，否则执行C。
3. if (A)
if (B) C
else D;
else
if (F) H
else K;

输入三个数,按小到大输出。
main()
{ float a,b,c,t;
scanf("%f,%f,%f",&a,&b.&c); 4 2 1
if (a>b)
2 4 1
if (a>c)
1 4 2
if (b>c)
1 2 4
printf("%f,%f,%f",a,b.c);
}

switch 语句
switch(a)
{
case A : B; break;
case C : D; break;
default : F; break;
}
如果变量a=A,执行B；执行break语句，跳出swith语句。如果没有break语句，D，F语句也会执行。
如果变量a=C,执行B；其它情况执行F。

while 语句
while（A）
{
B;
}
如果条件A满足，执行B，否则执行下一句。(先判断，后执行。)
while(i<-5)
{
s=s+1;
i++;
}
如果i=1，则不满足i<-5，执行下一句。i值不变。

do-while 语句
do
{
A;
}
while(B);
先执行A，再判断B；如果B满足，再执行A，否则执行下一句。(先执行，后判断)
do
{
s=s+1;
i++;
}
while(i<-5)；
如果i=1，执行i++，i=4；不满足i<-5，执行下一句。

for 语句
for( A ; B ; C ) D;
A：为变量赋初值；
判断是否满足条件B；满足则执行D再执行C再判断B；
不满足则执行下一句。
for(i=1;i<=5;i++) s=s+1;

for(i=1,s=0;i<=5;i++) s=s+1;
for( ;i<=5;i++) s=s+1;
for( ;i<=5; )

break 语句
break 语句：终止循环。用于循环语句，switch语句。
while(A)
{
if (B) C; break;
......
}
执行break语句，跳出循环，执行后面的语句。

continue 语句
continue 语句：只结束本次循环，而不是终止整个循环。
while(A)
{
if (B) C; continue;
......
}
执行break语句，跳出循环，再判断A，继续执行循环。

追问

同一楼 我原谅你

Answer 2

p为b的首地址了，他得到了b的内存空间，但他还是ABC结构体类型，他可以通过结构体ABC操作b的那部分内存空间，所以，如果ABC结构体的size大于2*4字节（即b分配到的栈空间）的话，这样去操作p就会溢出。 举个例子：
#include <stdio.h>
typedef struct _ABC_
{
int a;
int b;
}ABC,*pABC;
int main()
{
unsigned short b[4];
ABC* p=(ABC*)&b[0];
p->a=65537;//0x(00 00 00 01 00 00 00 01)通过p操作数组b
p->b=5;//0x(00 00 00 00 00 00 00 00 05)
printf("%d,%d,%d,%d",b[0],b[1],b[2],b[3]);//1,1,0,5。打印数组结果
}

追问

出来的结果是1150 为什么b[0]等于a里面的低字节 b[1]反而等于a的高字节 但是用楼下的代码 把666换成65537 把p->y=777去掉 运行后 b[0]还是等于65537的低字节的1 但是b[1]却没有像你这个代码里面等于高字节的1 而是继续是之前的赋值结果3 为什么

追答

高低字节和机器大小端模式相关。现在一般是小端模式。下面两个赋值，在小端模式中就是：
p->a=65537;//0x(00 00 00 01 00 00 00 01)
p->b=5;//0x(00 00 00 00 00 00 00 00 05)
内存存储：0x(01 00 00 00 01 00 00 00 | 05 00 00 00 00 00 00 00)
那么对于数组b来说就是：（“|”分割）
0x(01 00 00 00 |01 00 00 00 | 05 00 00 00 |00 00 00 00)
所以b[0],b[1],b[2],b[3]分别为1,1,5,0
对于你说的楼下的你要看清它ABC结构体里面的变量是unsigned short int,那么就能理解了。

Answer 3

ABC * p; //这句定义一个指向ABC的指针，但是并没有初始化，就是没有指向空间
unsigned short b[4];
p = (ABC *)&b[0]; //这句是将数组第一个元素地址赋给p，这样p就指向内存空间了，p就可以操作结构体ABC的成员变量和函数了。但是因为p指向的是数组b的内存地址，所以对p的成员变量的操作，都会影响到数组元素的值，可能会导致程序崩溃！下面是演示代码，运行一下就明白了：
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
struct ABC
{
unsigned short int x;
unsigned short int y;
};
int main()
{
ABC *p=NULL;
unsigned short int b[4]={2,3,4,5};
p=(ABC *) &b[0];
p->x=666;
p->y=777;
cout<<p->x<<endl;
cout<<p->y<<endl;
cout<<b[0]<<endl;
cout<<b[1]<<endl;
cout<<b[2]<<endl;
cout<<b[3]<<endl;
return 0;
}

如果数组的大小 < 结构体的大小，就会溢出，崩溃！

追问

追问如同二楼的内容 你俩的代码运行出来感觉原理不一样 不知道为什么

Answer 4

3分之8根号3 由条件可以求得AC的边长为2根号3，BC为2，设C到AB的4π

追问

……我原谅你