【C++ Lab】 对于解引用符*以及与运算符[]优先级的探索
 
【结论】
【验证过程】
阶段一 探究初步
阶段二 理解解引用符——*
阶段三 步入正题——[]与*优先级探索
  
 


 我想很多人都看过运算符优先级表，但有时候对于一些情况可能会混淆，不过一个万能方法是——加括号改变/确保优先级。尽管"加括号"确实是个万能方法，但在有时间去摸索的时候还是尽可能弄清楚优先级为好，这样更有助于理解，甚至可以在摸索的过程中发现"新大陆"，这也是做此次探索的目的。
 
【结论】
 
先把结论摆上吧：
 【结论一】解引用符*不能"解空气"，即被解引用的指针变量不能为野地址或NULL

 【结论二】运算符[]的优先级高于解引用符*。因此对于一个二级指针如int** a;，如果要用它来表示一个一维数组，则数组中元素表示为(*a)[i]，其中的小括号不能少。
 
【验证过程】
 
阶段一 探究初步
 
#include<iostream>
#include<stdlib.h>

int main(){
	using namespace std;
	int ** a=NULL; //注意悬空，防止野指针 
	//cout<<"a="<<a<<endl;
	*a = (int*)malloc(sizeof(int)*3);
	for(int i=0;i<3;++i)
		(*a)[i] = i+1;
		
	for(int i=0;i<3;++i)
		cout<<(*a)[i]<<endl;
		
	return 0;
}
 
【运行结果】
 
 
阶段二 理解解引用符——*
 
以上为我一开始写的代码，但是一运行就发现main函数返回了一个很大的值(如上图)，显然是出现了问题(即便我不把指针变量a悬空也是如此)，其实原因很简单，我当时并没有给指针变量a本身提供一个"合法处所"，即少了一句a=(int**)malloc(sizeof(int));，但这就使得二级指针a充当着二维数组了(我们是想要把二级指针a用于一维数组)，因此我把代码改了改，如下代码块所示。
 
#include<iostream>
#include<stdlib.h>

int main(){
	using namespace std;
	int ** a=NULL; //注意悬空，防止野指针 
	int* arr=NULL;
	a = &arr;
	//cout<<"a="<<a<<endl;
	*a = (int*)malloc(sizeof(int)*3);
	for(int i=0;i<3;++i)
		(*a)[i] = i+1;
		
	for(int i=0;i<3;++i)
		cout<<(*a)[i]<<endl;
		
	return 0;
}
 
【运行结果】
 
 可能有人会有疑问了，为何在不改变第一个代码块代码的前提下，仅仅添加了int* arr=NULL; a=&arr;后，就能正常运行了呢？关键在于a指针变量所指的地址是否存在。
 
我们要明白*a的意思是"对于a所指的地址解引用，并取其存储的值"，对于一开始的int ** a=NULL; *a = (int*)malloc(sizeof(int)*3);，a是空指针，没有指向实际的地址，这时候*a即取虚空地址存储的值，相当于"取空气"，这当然是非法的了，这种情况下就需要先给a本身申请一个存储空间，也就是对应着a=(int**)malloc(sizeof(int));，然后再进行后续的解引用等指令。
 
对于后面的代码块，这时候a=&arr;，尽管arr=NULL，但是它的地址是非空的，即&arr!=NULL，这时候赋予a的自然就是一个实实在在的"合法处所"了，因此*a——对于a的解引用就是"名正言顺"了。
 
到此我们可以得出【结论一】：解引用符*不能"解空气"，即被解引用的指针变量不能为野地址或NULL
 
阶段三 步入正题——[]与*优先级探索
 
这一步其实很简单，我们只要把第二个代码块中(*a)[i]所加的小括号去掉就好，如果运行结果符合预期，那么就说明解引用符*的优先级高于运算符[]；若运行出错，则说明解引用符* 的优先级低于运算符[]。
 
#include<iostream>
#include<stdlib.h>

int main(){
	using namespace std;
	int ** a=NULL; //注意悬空，防止野指针 
	int* arr=NULL;
	a = &arr;
	cout<<"The address of arr is "<<&arr<<endl;
	*a = (int*)malloc(sizeof(int)*3);
	for(int i=0;i<3;++i)
		*a[i] = i+1;
		
	for(int i=0;i<3;++i)
		cout<<*a[i]<<endl;
		
	return 0;
}
 
【运行结果】
 
 去掉小括号运行就出错了，从而得到了我们的【结论二】：运算符[]的优先级高于解引用符*
 
所以有些时候，如果对于网上的答案持怀疑态度，那么不妨自己设计个简单实验试试，说不定你就找到了答案，并且这远比你去网上搜寻得到的解答印象深刻。
 
如果文章中有不妥之处，欢迎大家在评论区指点批评~

我是刚学习入门的小苗子。这是我的第一个android应用程序。

虽然这个例子网络上已经很多了，自己能独立想出来还是很兴奋。

记录自己的成长。慢慢的赶上大家。





[img]http://dl.iteye.com/upload/picture/pic/110791/07872eef-466a-3fce-a61c-24e1140dabf4.jpg[/img]





思路：假设有一个存在一个f方法能解四则运算（运算优先级如）以下问题

f("1+2+3"）=6

f("1+2")=3

f("1")=1

规律f("1+2+3")=f(1)+f（2）+f(3)



假设f（"1+2*3"）

可以看成f("1")+f（"2*3"）

f("2*3")看成f（"2"）*f（"3"）



用递归可以解这个问题。递归的最终的返回条件是字符串里没有符号是数字

先按最后一个加号拆，再按最后一个乘除拆可以实现从左往右运算，加减乘除优先级。



如f（"1+2-3*4")=f("1+2")-f（"3*4"）;



如果存在（）的话如何解呢？

如f（"1+2+（3+4）"）



我把"3+4"看成是一个字符串$0;

那么f（"1+2+（3+4）"）=f（1+2+$0）=f(1)+f(2)+f($0);

f($0)=f(3+4)=f(3)+f(4)





以下是代码的实现



后台打印如

[img]http://i.6.cn/cvbnm/5d/b3/2f/8ae460ec1e7b0b634a2b0c02876e741f.jpg[/img]








import java.util.ArrayList;
public class DoCounter {

	static ArrayList<String> list;

	public static void main (String[] args)
	 {
		 System.out.println(result("((√4+(sin30)/2)*2)-1"));		 
	 }


		public static String result(String s)
		{
			list=new ArrayList<String>();
			try{
				System.out.println("-------------------------");
				System.out.println("-------------------------");
				System.out.println("------解析过程--------");
				System.out.println(s);
				String parse_string=(parse(s.trim()));
				System.out.println("------$引用索引--------");
				System.out.print("[\n");
				for(int i=0;i<list.size();i++)
				{
					System.out.print(" "+"$"+i+"="+list.get(i)+"\n");
				}
				System.out.print("]");
				System.out.println("------*******--------");
				System.out.println("------运算过程--------");
				String result_string=""+f(parse_string);
				System.out.println("------运算结果--------");
				System.out.println("结果输出："+result_string);
				System.out.println();




				return result_string;

			}
		    catch(Exception e)
		    {
		    	System.out.println("null");
		    	return "null";
		    }
		}


		//该方法（）的内容由$在list中进行索引
		public static String parse(String s) throws ArithmeticException {
			if(s.matches("[+-//*/]{2,}"))
	    	{
	    		throw new ArithmeticException(); 
	    	}
			int fri;
			int end;
			if((fri=s.lastIndexOf("("))!=-1)
			{
			  for(int i=fri;i<s.length();i++)
			  {

				  if(s.charAt(i)==')')
				  {
					 end=i;
					 String str=s.substring(fri+1,end);
					String turnstr=s.substring(0, fri)+"$"+list.size()+s.substring(end+1, s.length());
					  System.out.println(turnstr);
					  list.add(str);
					  return parse(turnstr);
				  }
			  }
			}
			return s;
		}


		//f方法递归运算法则求解
		public static double f(String s) throws ArithmeticException {

	        try{
	        //递归求解符号优先级自上往下----优先级	




	        	if(s.lastIndexOf("+")!=-1||s.lastIndexOf("-")!=-1)
	        	{
	        		return jia_jian(s);
	        	}


	            if(s.lastIndexOf("*")!=-1||s.lastIndexOf("/")!=-1
	            		||s.lastIndexOf("%")!=-1)
	        	{
	            	return cheng_chu_rest(s);
	        	}

	        //符号运算
			if (s.indexOf("√") == 0)
			{
				return sqrt(s);	
			}

			if (s.indexOf("sin")==0)
			{
				return sin(s);
			}
			if (s.indexOf("cos")==0)
			{
				return cos(s);
			}
			if (s.indexOf("tan")==0)
			{
				return tan(s);
			}

			//最高优先级，将()看做一个字符串处理，由$索引在List中引用
			if (s.indexOf("$") == 0)
			{
				System.out.println();
				return $(s);
			}

			//运算将表达式拆解到无任何符号则直接返回该值

			System.out.println("数字"+s);
			return Double.parseDouble(s);

		}catch(Exception e)
		{
			throw new ArithmeticException(); 
		}

	}


		public static double jia_jian(String s)
		{
			if(s.lastIndexOf("+")-s.lastIndexOf("-")>0)
			{	

	            int i=s.lastIndexOf("+");

		        return	(s.substring(0,i).equals("")? 0:f(s.substring(0, i)))
		        		+f(s.substring(i+1, s.length()));

			}
			else
			{

				int i=s.lastIndexOf("-");
				return	(s.substring(0,i).equals("")? 0:f(s.substring(0, i)))
			    		-f(s.substring(i+1, s.length()));
			}
		}


		public static double jia(String s)
		{
			String[] str = s.split("\\+");
			double d = str[0].equals("")?0:f(str[0]);
			for (int i = 1; i < str.length; i++) {

				d += f(str[i]);
			}

			return d;
		}
		public static double jian(String s)
		{
			String[] str = s.split("-");
			double d = str[0].equals("")?0:f(str[0]);
			for (int i = 1; i < str.length; i++) {

				d -= f(str[i]);
			}

			return d;
		}


		public static double cheng_chu_rest(String s)
		{
			int i1=s.lastIndexOf("*");
			int i2=s.lastIndexOf("/");
			int i3=s.lastIndexOf("%");
			if( i1>i2 && i1 >i3 )
			{

				return	f(s.substring(0, s.lastIndexOf("*")))
	    		*f(s.substring(s.lastIndexOf("*")+1, s.length()));
			}
			else if( i2>i1 && i2 >i3 )
			{
				System.out.println("/");
				return	f(s.substring(0, s.lastIndexOf("/")))
	    		/f(s.substring(s.lastIndexOf("/")+1, s.length()));

			}
			else
			{
				System.out.println("%");
				return	f(s.substring(0, s.lastIndexOf("%")))
	    		%f(s.substring(s.lastIndexOf("%")+1, s.length()));

			}
		}

		public static double cheng(String s)
		{
			String[] str = s.split("\\*");
			double d =f(str[0]);
			for (int i = 1; i < str.length; i++) {

				d*=f(str[i]);
			}

			return d;
		}
		public static double chu(String s)
		{
			String[] str = s.split("\\/");
			double d =f(str[0]);
			for (int i = 1; i < str.length; i++) {

				d/=f(str[i]);
			}
			return d;
		}

		public static double sqrt(String s)
		{

			String[] str=s.split("√");
			return f(""+Math.sqrt(f(str[1])));
		}

		public static double $(String s)
		{
			//将$解析，在ArrayList的索引中取出字符加入到f方法中递归
			String[] str=s.split("\\$");
			return f(list.get(Integer.parseInt(str[1])));	
		}

		private static double sin(String s) {
			String[] str=s.split("sin");
			return Math.sin(Math.PI/180*f(str[1]));	
		}
		private static double cos(String s) {
			String[] str=s.split("cos");
			return Math.cos(Math.PI/180*f(str[1]));
		}
		private static double tan(String s) {
			String[] str=s.split("tan");
			return Math.tan(Math.PI/180*f(str[1]));
		}
}

C 运算符优先级
 
下表列出 C 运算符的优先级和结合性。运算符从顶到底以降序列出。
 
优先级
运算符
描述
结合性
1
++ --
后缀自增与自减
从左到右
()
函数调用
[]
数组下标
.
结构体与联合体成员访问
->
结构体与联合体成员通过指针访问
(type){list}
复合字面量(C99)
2
++ --
前缀自增与自减[注 1]
从右到左
+ -
一元加与减
! ~
逻辑非与逐位非
(type)
转型
*
间接（解引用）
&
取址
sizeof
取大小[注 2]
_Alignof
对齐要求(C11)
3
* / %
乘法、除法及余数
从左到右
4
+ -
加法及减法
5
<< >>
逐位左移及右移
6
< <=
分别为 < 与 ≤ 的关系运算符
> >=
分别为 > 与 ≥ 的关系运算符
7
== !=
分别为 = 与 ≠ 关系
8
&
逐位与
9
^
逐位异或（排除或）
10
|
逐位或（包含或）
11
&&
逻辑与
12
||
逻辑或
13
?:
三元条件[注 3]
从右到左
14[注 4]
=
简单赋值
+= -=
以和及差赋值
*= /= %=
以积、商及余数赋值
<<= >>=
以逐位左移及右移赋值
&= ^= |=
以逐位与、异或及或赋值
15
,
逗号
从左到右
↑ 前缀 ++ 与 -- 的运算数不能是转型。此规则在文法上禁止某些表达式本来也会在语义上非法的表达式。某些编译器忽略此规则并检测语义上的非法。
↑ sizeof 的运算数不能是类型转型：表达式 sizeof (int) * p 无歧义地转译成 (sizeof(int)) * p ，而非 sizeof((int)*p) 。
↑ 条件运算符中部（ ? 与 : 之间）的表达式分析为如同加括号：忽略其相对于 ?: 的优先级。
↑ 赋值运算符的左运算数必须是一元（第 2 级非转型）表达式。此规则在文法上禁止某些表达式本来也会在语义上非法的表达式。从而许多编译器忽略此规则并在语义上检测其非法。例如， e = a < d ? a++ : a = d 是因此规则而无法剖析的表达式。然而许多编译器忽略此规则并将它剖析成 e = ( ((a < d) ? (a++) : a) = d ) ，并给出错误，因为它在语义上非法。
分析表达式时，列于上面表中某行的运算符，将比列于低于它的行中拥有较低优先级的任何运算符，更紧密地绑定到其参数（如同用括号）。例如，表达式 *p++ 被分析为 *(p++) ，而非 (*p)++ 。
 
拥有相同优先级的运算符以其结合性的方向绑定到其参数。例如表达式 a = b = c 被分析为 a = (b = c) 而非 (a = b) = c ，因为从右到左结合性。
 
注解
 
优先级和结合性与求值顺序独立。
 
标准自身不指定优先级。它们派生自文法。
 
C++ 中，条件运算符拥有与赋值运算符相同的优先级，而前缀 ++ 与 -- 及赋值运算符无关于其运算数的限制。
 
结合性规定对于一元运算符是冗余的，且只为完备而显示：一元前缀运算符始终从右到左结合（ sizeof ++*p 为 sizeof(++(*p)) ）而一元后缀运算符始终从左到右结合（ a[1][2]++ 为 ((a[1])[2])++ ）。注意结合性对成员访问运算符有意义，即使在它们与一元后缀运算符组合时： a.b++ 分析为 (a.b)++ 而非 a.(b++) 。
 
 
 
C++ 运算符优先级
 
下表列出 C++ 运算符的优先级和结合性。各个运算符以优先级的降序从上至下列出。
 
优先级
运算符
描述
结合性
1
::
作用域解析
从左到右
2
a++   a--
后缀自增与自减
type()   type{}
函数风格转型
a()
函数调用
a[]
下标
.   ->
成员访问
3
++a   --a
前缀自增与自减
从右到左
+a   -a
一元加与减
!   ~
逻辑非和逐位非
(type)
C 风格转型
*a
间接（解引用）
&a
取址
sizeof
取大小[注 1]
co_await
await 表达式 (C++20)
new   new[]
动态内存分配
delete   delete[]
动态内存分配
4
.*   ->*
成员指针
从左到右
5
a*b   a/b   a%b
乘法、除法与余数
6
a+b   a-b
加法与减法
7
<<   >>
逐位左移与右移
8
<=>
三路比较运算符(C++20 起)
9
<   <=
分别为 < 与 ≤ 的关系运算符
>   >=
分别为 > 与 ≥ 的关系运算符
10
==   !=
分别为 = 与 ≠ 的关系运算符
11
a&b
逐位与
12
^
逐位异或（互斥或）
13
|
逐位或（可兼或）
14
&&
逻辑与
15
||
逻辑或
16
a?b:c
三元条件[注 2]
从右到左
throw
throw 运算符
co_yield
yield 表达式 (C++20)
=
直接赋值（C++ 类默认提供）
+=   -=
以和及差复合赋值
*=   /=   %=
以积、商及余数复合赋值
<<=   >>=
以逐位左移及右移复合赋值
&=   ^=   |=
以逐位与、异或及或复合赋值
17
,
逗号
从左到右
↑ sizeof 的操作数不能是 C 风格转型：表达式 sizeof (int) * p 无歧义地解释成 (sizeof(int)) * p ，而非 sizeof((int)*p)。
↑ 条件运算符中部（? 与 : 之间）的表达式分析为如同其带有括号：忽略其相对于 ?: 的优先级。
分析表达式时，列于上面表中某行的运算符，将比列于低于它的行中拥有较低优先级的任何运算符，更紧密地与其实参相绑定（如同用了括号）。例如，表达式 std::cout << a & b 和 *p++ 被分析为 (std::cout << a) & b 和 *(p++)，而非 std::cout << (a & b) 或 (*p)++。
 
拥有相同优先级的运算符以其结合性的方向与各参数绑定。例如表达式 a = b = c 被分析为 a = (b = c) 而非 (a = b) = c，因为赋值具有从右到左结合性，但 a + b - c 被分析为 (a + b) - c 而非 a + (b - c)，因为加法和减法具有从左到右结合性。
 
结合性规定对于一元运算符是冗余的，只为完备而给出：一元前缀运算符始终从右到左结合（delete ++*p 为 delete(++(*p))）而一元后缀运算符始终从左到右结合（a[1][2]++ 为 ((a[1])[2])++）。要注意，结合性对成员访问运算符是有意义的，即使在它们与一元后缀运算符组合时也是如此：a.b++ 分析为 (a.b)++ 而非 a.(b++)。
 
运算符优先级不受运算符重载影响。例如，std::cout << a ? b : c; 分析为 (std::cout << a) ? b : c;，因为算术左移的优先级高于条件运算符。
 
注解
 
优先级和结合性是编译时概念，与求值顺序无关，后者是运行时概念。
 
标准自身不指定优先级。它们是从文法导出的。
 
表中并未包括 const_cast、static_cast、dynamic_cast、reinterpret_cast、typeid、sizeof...、noexcept 及 alignof，因为它们决不会有歧义。
 
一些运算符拥有代用写法（例如，&& 可为 and、|| 可为 or、! 可为 not 等）。
 
C 中，三元条件运算符拥有高于赋值运算符的优先级。因此，表达式 e = a < d ? a++ : a = d 在 C++ 中剖析成 e = ((a < d) ? (a++) : (a = d))，但在 C 中会由于 C 的语法或语义制约而编译失败。细节见对应的 C 页面。

 注意指针解引用必须括在括号，因为成员选择运算符具有比解引用操作符的优先级更高的。
 
 因为访问结构和类成员通过指针是笨拙的语法，C + +提供的第二个成员选择运算符（->）从指针做成员选择。下面的两行是等价的：
  
 
    

      1
    
 
    

      2
    
 
 
    
 
     
 
      (*psSomething).nValue = 5;
     
 
     
 
      psSomething->nValue = 5;
     
 
    
 
 
这不仅是容易的，但也更不容易出错因为没有优先的问题的担心。
因此
，
在做
成员访问
通过指针
，
总是使用
->
操作符
。
 

 
 
 
 
 是的，这是可能的，更多的是比使用矢量更难。
 
 当你说“动态大小的数组”，你想动态分配数组到一个特定的大小，或动态地调整现有的阵列？任何事都是可能的，但后者更难。
 
 另外，如果你通过一个非const引用数组的函数，这意味着函数要修改数组。不需要返回一个引用返回给调用者，因为调用者可以通过它原来的名字访问数组。
 
 在前面的课程中，你学到了局部变量（有块范围）和全局变量（有计划的范围）。还有另一个作用域的变量，可以水平：文件范围。
 
 文件范围内的变量可以被访问的任何功能或嵌在一个单一的文件。申报文件作用域的变量，简单地声明一个变量，一块外（同一个全局变量）但使用static关键字：
 
 同样，一个const引用的行为就像一个const指针指向const对象是隐式解引用。
 
 因为引用总是“点”来有效的对象，而不能指出释放内存，引用的是比使用指针安全。如果一个任务可以通过引用或指针解决，参考一般应首选。指针通常只能用在引用是不充分的情况下（如动态分配的内存）。
 
 成员的选择
 
 通常有一个指针或引用一个结构（或类）。正如你已知道的，你可以选择使用一个struct的成员选择运算符成员（。）：