跳至正文
View Categories

1 min read

主要内容 #

  1. 指针与函数
  2. 结构体指针

1. 指针与函数 #

1.1 传递指针给函数 #

通过引用或地址传递参数，使传递的参数在调用函数中被改变。
下面的实例中，传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

#include < iostream >
#include < ctime >
using namespace std;
 
// 在写函数时应习惯性的先声明函数，然后在定义函数
void getSeconds(unsigned long *par);
int main ()
{
   unsigned long sec;
   getSeconds( &sec );
 
   // 输出实际值
   cout << "Number of seconds :" << sec << endl;
   return 0;
}
 
void getSeconds(unsigned long *par)
{
   // 获取当前的秒数
   *par = time( NULL );
   return;
}

当上面的代码被编译和执行时，它会产生下列结果：

Number of seconds :1294450468

能接受指针作为参数的函数，也能接受数组作为参数，如下所示：

#include < iostream >
using namespace std;
 
// 函数声明
double getAverage(int *arr, int size);
int main ()
{
   // 带有 5 个元素的整型数组
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
   // 传递一个指向数组的指针作为参数
   avg = getAverage( balance, 5 ) ;
   // 输出返回值
   cout << "Average value is: " << avg << endl; 
   return 0;
}
 
double getAverage(int *arr, int size)
{
  int  i, sum = 0;       
  double avg;          

  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
   }
 
  avg = double(sum) / size;
  return avg;
}

当上面的代码被编译和执行时，它会产生下列结果：

Average value is: 214.4

1.2 从函数返回指针 #

C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。
C++ 允许从函数返回指针。为了做到这点，必须声明一个返回指针的函数，如下所示：

int * myFunction()
{
.
.
.
}

另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static变量。
下面的函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们，具体如下：

#include < iostream >
#include  <ctime >
#include  < cstdlib >
 
using namespace std;
 
// 要生成和返回随机数的函数
int * getRandom( )
{
  static int  r[10];
  // 设置种子
  srand( (unsigned)time( NULL ) );
  for (int i = 0; i < 10; ++i)
  {
    r[i] = rand();
    cout << r[i] << endl;
  }
  return r;
}
 
// 要调用上面定义函数的主函数
int main ()
{
   // 一个指向整数的指针
   int *p;
 
   p = getRandom();
   for ( int i = 0; i < 10; i++ )
   {
       cout << "*(p + " << i << ") : ";
       cout << *(p + i) << endl;
   }
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

624723190
1468735695
807113585
976495677
613357504
1377296355
1530315259
1778906708
1820354158
667126415
*(p + 0) : 624723190
*(p + 1) : 1468735695
*(p + 2) : 807113585
*(p + 3) : 976495677
*(p + 4) : 613357504
*(p + 5) : 1377296355
*(p + 6) : 1530315259
*(p + 7) : 1778906708
*(p + 8) : 1820354158
*(p + 9) : 667126415

2. 结构体指针 #

参照之前第94讲中结构体的内容，声明结构体Book：

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

struct Books *struct_pointer;

现在，可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，把 & 运算符放在结构名称的前面，如下所示：

struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，必须使用 -> 运算符，如下所示：

struct_pointer->title;

重写第94节第4部分的例子：

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

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C++ Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C++ Programming Tutorial");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );
 
   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );
 
   return 0;
}
void printBook( struct Books *book )
{
   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

当上面的代码被编译和执行时，它会产生下列结果：
运行以上程序后得到：

Book title : C++ Programming
Book author : Nuha Ali
Book subject : C++ Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700
What are your Feelings