C语言指针，求大侠帮忙解释解释。该怎么处理

2013-08-13

C语言指针，求大侠帮忙解释解释。本帖最后由 NowDoIT 于 2013-07-05 13:04:55 编辑大概是这样的：typedef str

C语言指针，求大侠帮忙解释解释。
本帖最后由 NowDoIT 于 2013-07-05 13:04:55 编辑大概是这样的：

typedef struct a s_a;
typedef struct b s_b;

struct a {
char *s;
};

struct b {
s_a r;
s_a *p;
}

struct s_b *var;

我想通过ar访问a结构体中的s;
如果 var->p->s 我能够理解，因为都是指针嘛；

如果要访问 r 中的 s，该怎么访问？
var->r.s 还是 var.r->s 或者是 &var->r->s ?

谢谢大家！
[解决办法]
var->r.s
(var->r).s

引用:

大概是这样的：
typedef struct a s_a;
typedef struct b s_b;

struct a {
char *s;
};

struct b {
s_a r;
s_a *p;
}

struct s_b *var;
我想通过ar访问a结构体中的s;
如果 var->p->s 我能够理解，因为都是指针嘛；

如果要访问 r 中的 s，该怎么访问？
var->r.s 还是 var.r->s 或者是 &var->r->s ?

谢谢大家！

[解决办法]
(var->r).s

//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called 
 
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//
[解决办法]
 Operator         
[解决办法]
 Name or Meaning                         
[解决办法]
 Associativity 
[解决办法]

//+------------------+-----------------------------------------+---------------+
//
[解决办法]
 ::               
[解决办法]
 Scope resolution                        
[解决办法]
 None          
[解决办法]

//
[解决办法]
 ::               
[解决办法]
 Global                                  
[解决办法]
 None           
 
[解决办法]

//
[解决办法]
 [ ]              
[解决办法]
 Array subscript                         
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ( )              
[解决办法]
 Function call                           
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ( )              
[解决办法]
 Conversion                              
[解决办法]
 None          
[解决办法]

//
[解决办法]
 .                
[解决办法]
 Member selection (object)               
[解决办法]
 Left to right 
[解决办法]

//
------解决方案-------------------- 
 
 ->               
[解决办法]
 Member selection (pointer)              
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ++               
[解决办法]
 Postfix increment                       
[解决办法]
 None          
[解决办法]

//
[解决办法]
 --               
[解决办法]
 Postfix decrement                       
[解决办法]
 None          
[解决办法]

//
[解决办法]
 new              
[解决办法]
 Allocate object                         
[解决办法]
 None          
[解决办法]

//
[解决办法]
 delete           
------解决方案-------------------- 
 
 Deallocate object                       
[解决办法]
 None          
[解决办法]

//
[解决办法]
 delete[ ]        
[解决办法]
 Deallocate object                       
[解决办法]
 None          
[解决办法]

//
[解决办法]
 ++               
[解决办法]
 Prefix increment                        
[解决办法]
 None          
[解决办法]

//
[解决办法]
 --               
[解决办法]
 Prefix decrement                        
[解决办法]
 None          
[解决办法]

//
[解决办法]
 *                
[解决办法]
 Dereference                              
 
[解决办法]
 None          
[解决办法]

//
[解决办法]
 &                
[解决办法]
 Address-of                              
[解决办法]
 None          
[解决办法]

//
[解决办法]
 +                
[解决办法]
 Unary plus                              
[解决办法]
 None          
[解决办法]

//
[解决办法]
 -                
[解决办法]
 Arithmetic negation (unary)             
[解决办法]
 None          
[解决办法]

//
[解决办法]
 !                
[解决办法]
 Logical NOT                              
 
[解决办法]
 None          
[解决办法]

//
[解决办法]
 ~                
[解决办法]
 Bitwise complement                      
[解决办法]
 None          
[解决办法]

//
[解决办法]
 sizeof           
[解决办法]
 Size of object                          
[解决办法]
 None          
[解决办法]

//
[解决办法]
 sizeof ( )       
[解决办法]
 Size of type                            
[解决办法]
 None          
[解决办法]

//
[解决办法]
 typeid( )        
[解决办法]
 type name                               
------解决方案-------------------- 
 
 None          
[解决办法]

//
[解决办法]
 (type)           
[解决办法]
 Type cast (conversion)                  
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 const_cast       
[解决办法]
 Type cast (conversion)                  
[解决办法]
 None          
[解决办法]

//
[解决办法]
 dynamic_cast     
[解决办法]
 Type cast (conversion)                  
[解决办法]
 None          
[解决办法]

//
[解决办法]
 reinterpret_cast 
[解决办法]
 Type cast (conversion)                  
[解决办法]
 None          
[解决办法]

//
[解决办法]
 static_cast       
 
[解决办法]
 Type cast (conversion)                  
[解决办法]
 None          
[解决办法]

//
[解决办法]
 .*               
[解决办法]
 Apply pointer to class member (objects) 
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ->*              
[解决办法]
 Dereference pointer to class member     
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 *                
[解决办法]
 Multiplication                          
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 /                
[解决办法]
 Division                                
------解决方案-------------------- 
 
 Left to right 
[解决办法]

//
[解决办法]
 %                
[解决办法]
 Remainder (modulus)                     
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 +                
[解决办法]
 Addition                                
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 -                
[解决办法]
 Subtraction                             
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 <<               
[解决办法]
 Left shift                              
[解决办法]
 Left to right 
------解决方案-------------------- 
 

//
[解决办法]
 >>               
[解决办法]
 Right shift                             
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 <                
[解决办法]
 Less than                               
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 >                
[解决办法]
 Greater than                            
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 <=               
[解决办法]
 Less than or equal to                   
[解决办法]
 Left to right 
[解决办法]

//
------解决方案-------------------- 
 
 >=               
[解决办法]
 Greater than or equal to                
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ==               
[解决办法]
 Equality                                
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 !=               
[解决办法]
 Inequality                              
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 &                
[解决办法]
 Bitwise AND                             
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 ^                 
 
[解决办法]
 Bitwise exclusive OR                    
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 
[解决办法]
                
[解决办法]
 Bitwise OR                              
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 &&               
[解决办法]
 Logical AND                             
[解决办法]
 Left to right 
[解决办法]

//
[解决办法]
 
[解决办法]
               
[解决办法]
 Logical OR                              
[解决办法]
 Left to right 
[解决办法]

//
------解决方案-------------------- 
 
 e1?e2:e3         
[解决办法]
 Conditional                             
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 =                
[解决办法]
 Assignment                              
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 *=               
[解决办法]
 Multiplication assignment               
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 /=               
[解决办法]
 Division assignment                     
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 %=               
[解决办法]
 Modulus assignment                       
 
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 +=               
[解决办法]
 Addition assignment                     
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 -=               
[解决办法]
 Subtraction assignment                  
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 <<=              
[解决办法]
 Left-shift assignment                   
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 >>=              
[解决办法]
 Right-shift assignment                  
[解决办法]
 Right to left 
[解决办法]

//
------解决方案-------------------- 
 
 &=               
[解决办法]
 Bitwise AND assignment                  
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 
[解决办法]
=               
[解决办法]
 Bitwise inclusive OR assignment         
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 ^=               
[解决办法]
 Bitwise exclusive OR assignment         
[解决办法]
 Right to left 
[解决办法]

//
[解决办法]
 ,                
[解决办法]
 Comma                                   
[解决办法]
 Left to right 
[解决办法]

//+------------------+-----------------------------------------+---------------+

[解决办法]
(var->r).s
------解决方案--------------------

楼上都解决了....
[解决办法]
(var->r).s
[解决办法]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct a s_a;
typedef struct b s_b;
 
struct a {
    char *s;
};
 
struct b {
    s_a r;
    s_a *p;
};
int main(int argc, char *argv[])
{
//struct s_b *var;    //这种写法会让编译器报未定义指针类型的变量var
s_b *var = (s_b*)malloc(sizeof(s_b));
if (NULL == var)
{
fprintf(stderr, "malloc failed!\n");
exit(EXIT_FAILURE);
}
var->r.s = (char *)malloc(16);
if (NULL == var->r.s)
{
fprintf(stderr, "malloc failed!\n");
exit(EXIT_FAILURE);
}
var->p = &var->r;    //指针用于指向结构体变量
strcpy(var->r.s, "helloworld");
fprintf(stdout, "%s\n", var->p->s);
//puts(var->p->s);

return 0;
}

我通过测试加不加括号是一样的，不过，加上括号能够让表达式更好理解。
[解决办法]
是这样的：
结构体变量名.成员名；
指针变量名->成员名。
另外，指针变量名->成员名在计算机内部会被转化成(*指针变量名).成员名的方式来执行。
所以你这个问题的结果是 var->r.s
[解决办法]

引用:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct a s_a;
typedef struct b s_b;
 
struct a {
    char *s;
};
 
struct b {
    s_a r;
    s_a *p;
};
int main(int argc, char *argv[])
{
//struct s_b *var;    //这种写法会让编译器报未定义指针类型的变量var
s_b *var = (s_b*)malloc(sizeof(s_b));
if (NULL == var)
{
fprintf(stderr, "malloc failed!\n");
exit(EXIT_FAILURE);
}
var->r.s = (char *)malloc(16);
if (NULL == var->r.s)
{
fprintf(stderr, "malloc failed!\n");
exit(EXIT_FAILURE);
}
var->p = &var->r;    //指针用于指向结构体变量
strcpy(var->r.s, "helloworld"); 
 
fprintf(stdout, "%s\n", var->p->s);
//puts(var->p->s);

return 0;
}

我通过测试加不加括号是一样的，不过，加上括号能够让表达式更好理解。

都像你这么写代码，内存有多少都不够用的 C语言指针，求大侠帮忙解释解释。该怎么处理

[解决办法]
可能是每个人的看法都不同吧，在我眼里，有括号反而更乱，呵呵呵
[解决办法]
->是指针指向其成员的运算符
.是结构体的成员运算符
如：var->r.s="aaaaaa";
var是指针后面就接-> r是结构体（或者联合体）后面就接 .
如：var->p->s
var是指针后面就接-> p还是指针后面就接->
[解决办法]
var->r.s
[解决办法]
仔细看看书本上->和.各自使用场景
[解决办法]
C语言指针，求大侠帮忙解释解释。该怎么处理

[解决办法]
LZ的变量名s_b好奇葩阿 C语言指针，求大侠帮忙解释解释。该怎么处理

[解决办法]
s是r的成员，s虽然是指针(s是不是指针没有关系)但是r并不是指针，所以是.而不是->
[解决办法]
结构指针访问成员用->
结构实例访问成员用.

热点排行