C指针和位运算

跟据符号顺序依次判断类型

int p; //普通整型

int *p;//带*说明p是一个指针，int说明p是指向整型的指针

int p[3];//带[]说明p是一个数组，int说明数组里存放的是整型元素

int *p[3];//[]说明是数组,*说明数组里的元素是指针，int说明这些指针元素指向整型。所以p是一个储存了整型的指针所组成的数组。

int p(int);//p有()说明是个哈桑农户，函数有一个整型的参数，该函数返回的是整型

int (*p)(int);//*说明p是指针，()说明*p是指向函数的指针

指针的类型和指针指向的类型

int *p;
指针的类型是整型指针；
指针所指向的类型是整型；

int *pi;
*pi=5;
这样是错误的，因为整型指针只是声明但是没有实际的地址，赋值的话只有对象但是没有地址。

int a[3];
int *p,*q;
p=a;
q=&a[2];
这两种都是可以的,且(q-p)/sizeof(int)

const char *c = "hello";//常量代码区
char a[] = "hello";//数据区或者栈区

int *ptr;
ptr = (int*)0x8000;
这种随意直接分配地址的方式是十分危险的，因为可能并不知道这些地址指向什么地方

sizeof

char *a = "0123456789";
sizeof(a)
a是一个字符指针，指针的大小是定值，就是4字节

char a[] = "0123456789";
sizeof(a)
a是一个字符数组，数组最初未确定大小，填充后一个字符占一个字节，再加上隐含的\0，所以大小是11

char a[100]="0132465789"
sizeof(a)
a是一个字符数组，由于分配好了大小100，所以这个字符数组就是大小100

int a[100];
sizeof(a)
a是一个整型数组，一个整型的大小是4字节，所以最后整体的大小应该是400

char a[]="a\n"
sizeof(a)
由于\n算作是一个字节，所以最后加上\0大小是三

char var[10];
int test(char var[])
{
	return sizeof(var);
}
本来var代表这个数组，其sizeof为10，但是由于作为函数参数传入之后，就退化为指针了，指针的大小都是4

指针的值

指针的值是一个地址，在32位程序中是一个32位的整数。指针指向的区域就是，从这个地址开始，然后长度位sizeof的区域，指针就是这个区域的首地址。32位是4个字节大小。指针大小与类型无关，始终是4个字节。变量的大小才会有区别。

指针算数运算

char a[20];
int *ptr = (int *)a;
ptr++;

a是一个字符数组变量，使用(int *)类型转换成了一个整型的指针，方便后面进行运算，因为整型的才能做算数运算；但这里即使不转也可以直接用。
ptr加1，在32位中实际是加4，所以ptr指向的地址由原来的a的低地址向高增加了四个字节，本来ptr是指向数组a的开始的四个字节，此时指向（）

int array[20] = {0};//注意初始化的格式，后面要么不加初值，要么也是{0}这样加大括号的形式
int *ptr = array;
for(i=0;i<20;i++)
{
	(*ptr)++;
	ptr++;
}

运算符

&是取地址，取出来的是一个指针
*是取出这个指针所对应的内容

int a = 12;//a是个整型
int b; //b是个整型
int *p ;//p是个指向整型的指针
int **ptr;

p =&a;//把a的地址取出来给了p，从此p就指向a了

*p = 24;//p这个指针指向的内容变成24，也就是a=24

ptr = &p;//p这个指针的地址是ptr，所以ptr这个二级指针指向的是p这个一级指针

*ptr = &b;//现在让这个ptr二级指针指向的内容变成b这个内容的一级指针了

**ptr=34;//*ptr待变ptr指向的一级指针，**ptr代表这个一级指针指向的内容，也就是b，所以b=24了

指针表达式

表达式的结果是指针，就是指针表达式

int a,b;
int array[10];
int *pa;

pa = &a;//a的地址为pa，pa指向a
int **ptr = &pa;//pa这个指针的地址为ptr这个二级指针
*ptr = &b;//这两边都是指针表达式

数组和指针

int a;//一个整型数
int *a;//一个指向整型数的指针
int **a;//一个指向整型数指针的指针
int a[10]//一个整型数组
int *a[10]//一个存放着指向整型数的指针的数组
int (*a)[10]//一个指向10个元素的整型数组的指针
int (*a)(int)//一个返回值为整型，参数为整型的函数的指针
int (*a[10])(int)//

int a[] = {1,2,3,4,5};
int *ptr = (int*)(&a+1);
printf("%d %d",*(a+1),*(ptr-1));

a首先是一个数组的指针，其次这个指针里还存放这个数组的大小
&a得到的是这个数组的地址，这个地址直接加1的结果就相当于加上了这个数组的大小。这个时候遍指向了第六个不存在的元素。这个元素的指针减1就是第五个元素的指针，*将这个值取出来
而a这个指针直接加1的话就是直接下一个元素

所以：地址加1就是加了这个数组的大小，指针加1就是下一个元素

int *p[n];//指针数组，每个元素均为指向整型数据的指针
int (*p)[n];//p这个指针指向了有n个整型的数组，p为这个整型数组的指针
不要这样赋值 *ptr[]=5,因为没有地址，必须先让ptr[5]=a这样存有地址才行
int *(ptr[])和上面相同

int v[2][3]={{1,2},{3,4}};
int (*a)[2]=v;
cout<<**a;//1
cout<<**(a+1)//3
cout<<*(*a+1);//2
cout<<*(a[0]+1)//2
cout<<*(a[1])//3

这个数组的指针是v，而a这个数组的指针指向了v这个指针，所以a是一个二级指针，即指针的指针a=&v，按照上面的理论，a+1就是地址加1，直接加上了这个数组的大小.而*a=v是指针加1相当于下一个元素
里面的a+1相当于加了一个数组大小，所以到了下一个数组处
*a+1相当于指针向后移动1个，指向下一个元素

char * a[]={"hello","the","world"}
char **pa = a;
pa++;
cout<<*pa;
a是一个二级指针，指向了这个数组的指针的指针。pa也是一个二级指针，接收了a的值。pa是这个这个数组指针的地址，地址直接加1的结果就是加上了当前额sizeof，所以直接到了第二个的开头，打印*pa输出的是the

char str1[] = "abc";//字符数组,str1存的是字符数组的首地址
对其求sizeof是数组的长度，专门有个‘数组的指针’的机制，但是当作为函数参数等情况发生后就变为‘普通的指针’了
const char* str3 = "abc";//str3是一个字符指针，str3指向该常量储存区的首地址的指针

int array[10]={0,1,2,3,4,5,6,7,8,9},value;
value = *array;
value = *(array+3);
value = *(array+4);

数组名代表的是数组，也可以看作是指向第一个元素的指针

char s[3]={};
s就是这个数组的指针，s的值就是第一个元素的首地址，这个时候代表的是整个的数组，求sizeof也求的是整个的数组的长度。s的类型是char *的类型，指向的是char数组。
char *str[3] = {};
str这里是一个二级指针，类型是char**,指向的是char*,str是一个放有三个指针的数组，元素都是指针，每个指针都指向一个字符串，所有赋值的时候{}里面就代表这些指针分别指向的字符串。注意字符串算是一种字符常量，内容不能改变，有const属性。
*str是一个指针，它的类型是char*，它所指向的类型是char，所指向的地址是字符串第一个字符的地址。
*(str+1)也是一个指针，指向的是数组的一号元素，指向的类型是char

TYPE array[n];
对于数组名array有两层含义，
1.它就代表这个数组。类型是TYPE[N]；
2.它也看成一个常量指针，指针的类型是TYPE*，指针指向的类型是TYPE，指向的内容是数组的0号元素，但是注意它和0号单元的地址是不一样的，是在常量区，因为始终会指向这个0号元素这个位置，但是这个位置的值可以通过0号元素的指针去进行修改。所以对这个常量指针求sizeof的结果得到的是这个数组的长度。
*array直接就代表的是这个数组0号元素的值了，而求后面的元素的值要先对指针进行加减，如*(array+1)代表的是第一号元素，这时对这个指针求sizeof得到的就直接是本身指针的大小了，也就是4了

struct my
{
int a;
int b;
}
struct my ss = {10,20};
struct my* ptr = &ss;
int *ptrs = (int*)&ss;
ptr的类型为struct my *，对象ss的地址赋给这个指针，以后ptr就是ss的指针，即*ptr=ss
&ss的类型经过强制类型转换后变为int *型，然后给到ptrs，ptrs和ptr的类型是不同的

通过ss访问成员：
ss.a
ss.b
通过ptr访问成员：（对于指针类型的使用->访问，迭代器也是，链表的节点指针也是）
ptr->a
pts->b
通过ptrs访问成员：（非常不推荐，因为结构体成员之间可能存在空隙，而数组可以这样做，因为数组是顺序储存的）
*ptrs
*(ptrs+1)

int array[3] = {};
int *p = array;
array是这个数组的指针，int *类型的p直接等于array，注意这里不用再对array取地址了
*p直接就是0号元素
*(p+1)1号元素

		char p1[] = "123";
		char p2[] = "123";
		const char *p3 = "test";//这个const不加编译器会报错的，因为这样定义的就是一个常量，常量在常量区，只有一份
		const char *p4 = "test";
		bool b1 = p1 == p2;
		bool b2 = p3 == p4;
		cout <<b1 << endl;//答案为0，因为每个地址下都有自己的123
		cout << b2 << endl;//答案为1，放在的是常量区，只有一份备份

指针和函数

int func1(char *s)
{
	int num = 0;
	for(int i = 0;;)
	{
		num+=*s;
		s++;
	}
	return num;
}
int a;
char str[] = "asd";
a = fun(str);

str数组名代表这个数组，同时也是这个数组的0号元素的指针，通过函数进行传入统计ASCII码值

指针类型转换

void fun(char *s)
{
char c;
c = *(s+3);
*(s+3)=*(s);
*s = c;
}
int a = 125,b;
fun((char *)&a);

&a取地址之后，类型是int *，要想作为参数还需要转换成char *，进行强制类型转换。int类型是四个字节，char类型是一个字节，fun把这个int的四个字节首位进行颠倒

int a = 123,b;
int *ptr = &a;
char *str;
b = (int)ptr;
str = (char*)b;

ptr是a的指针，用强制类型转换把a的地址取出来了然后作为整数给了b，然后又把这个整数转换为char*的类型赋给str，现在str的类型是char*，指向的是char，地址就是b的值

转换的安全问题

ptr1 = (TYPE *)ptr2；
如果sizeof(ptr2)大于sizeof(ptr1)，那么使用ptr1来访问ptr2所指向的储存区是安全的。但是如果小于了，会造成不安全的情况。

char s = 'a';
int *ptr;
ptr = (int*)&s;
*ptr = 1298;

ptr是int*的指针，指向的是int,指向的地址就是s的首地址。但是s只占一个字节，int占4个字节，*ptr=1298不仅改变了s对应的字节内容，还把s地址后面的三个字节的未知给修改了，造成了不安全

浮点型强制类型转换

float a = 1.0f;
cout << (int)a << endl;
cout << (int&)a << endl;
cout << ( (int)a == (int&)a ) << endl; 

0

这和浮点数存储有关系:
float 1.0在内存中存储为:
符号位  阶(指数)   尾数
0       01111111   00000000000000000000000

关于浮点数存储可以参见有关标准。

转化为int&后，数据就变为00111111100000000000000000000000 = 1065353216

float b = 0.0f;
cout << (int)b << endl;
cout << (int&)b << endl;
cout << ( (int)b == (int&)b ) << endl; 

1

位运算

n&(n-1)

1.	n&(n-1)消除二进制下最后出现1的位置，其余保持不变

(1)任意给定一个32位无符号整数n，求n的二进制表示中1的个数
	Int func(int x)
{
Int count = 0;
While(x)
{
Count++;x =x&(x-1);
}
}
(2)判断一个数是否为2的n次方
n&(n-1)==0?

加减法

	//1.两种加法运算，运行时间：3ms，占用内存：468k
	int Add(int num1, int num2)
	{
		int sum, carry;
		while (num2 != 0)
		{
			//sum是和，而carry是进位，sum表示计算的①，carry表示计算的②，不断地进行①与②，直到②为0
			sum = num1^num2;
			carry = (num1&num2) << 1;
			num1 = sum;
			num2 = carry;
		}
		return num1;
	}

	int Add2(int num1, int num2)
	{
		if (num2 == 0)
			return num1;
		int sum = num1^num2;
		int carry = (num1&num2) << 1;
		Add2(sum, carry);
	}

	//2.一种减法运算
	int Negtive(int num1, int num2)
	{
		//减法即num1+(-num2),注意计算机用补码存的，所以-num2 = ~(num2 - 1) = ~num2 + 1 = Add(~num2,1)
		return Add(num1, Add(~num2, 1));
	}