【第四版课后习题答案】 第06章 数组、指针与字符串

第六章数组、指针与字符串

6-1 数组A[10][5][15]一共有多少个元素？

解：

10×5×15 = 750 个元素

6-2 在数组A[20]中第一个元素和最后一个元素是哪一个？

解：

第一个元素是A[0]，最后一个元素是A[19]。

6-3 用一条语句定义一个有五个元素的整型数组，并依次赋予1~5的初值。

解：

源程序：

int IntegerArray[5] = { 1，2，3，4，5 };

或：int IntegerArray[] = { 1，2，3，4，5 };

6-4 已知有一个数组名叫oneArray，用一条语句求出其元素的个数。

解：

源程序：

nArrayLength = sizeof(oneArray) / sizeof(oneArray[0]);

6-5 用一条语句定义一个有5×3个元素的二维整型数组，并依次赋予1~15的初值。

解：

源程序：

int theArray[5][3] = { 1，2，3，4，5，6，7，8，9，10，11，12，13，14，15 };

或：int theArray[5][3] = { {1，2，3}，{4，5，6}，{7，8，9}，{10，11，12}，{13，14，15} };

6-6 运算符*和&的作用是什么？

解：

*称为指针运算符，是一个一元操作符，表示指针所指向的对象的值；&称为取地址运算符，也是一个一元操作符，是用来得到一个对象的地址。

6-7 什么叫做指针？指针中储存的地址和这个地址中的值有何区别？

解：

指针是一种数据类型，具有指针类型的变量称为指针变量。指针变量存放的是另外一个对象的地址，这个地址中的值就是另一个对象的内容。

6-8 声明一个整型指针，用new语句为其分配包含10个整型元素的地址空间。

解：

源程序：

int *pInteger = new int[10];

6-9 在字符串”Hello，world!”中结束符是什么？

解：

是NULL字符。

6-10 定义一个有五个元素的整型数组，在程序中提示用户输入元素值，最后再在屏幕上显示出来。

解：

源程序：

#include

int main()

{

int myArray[5];

int i;

for ( i=0; i<5; i++)

{

cout << "Value for myArray[" << i << "]: ";

cin >> myArray[i];

}

for (i = 0; i<5; i++)

cout << i << ": " << myArray[i] << "\n";

return 0;

}

程序运行输出：

Value for myArray[0]: 2

Value for myArray[1]: 5

Value for myArray[2]: 7

Value for myArray[3]: 8

Value for myArray[4]: 3

0: 2

1: 5

2: 7

3: 8

4: 3

6-11 引用和指针有何区别？何时只能使用指针而不能使用引用？

解：

引用是一个别名，不能为NULL值，不能被重新分配；指针是一个存放地址的变量。当需要对变量重新赋以另外的地址或赋值为NULL时只能使用指针。

6-12 声明下列指针：float类型变量的指针pFloat，char类型的指针pString和struct customer 型的指针prec。

解：

float *pfloat;

char *pString;

struct customer *prec;

6-13 给定float类型的指针fp，写出显示fp所指向的值的输出流语句。

解：

cout << "Value == " << *fp;

6-14 程序中定义一个double类型变量的指针。分别显示指针占了多少字节和指针所指的变量占了多少字节。

解：

double *counter;

cout << "\nSize of pointer == "sizeof(counter);

cout << '\nSize of addressed value == "<

6-15 const int * p1 和int * const p2的区别是什么？

解：

const int * p1 声明了一个指向整型常量的指针p1，因此不能通过指针p1来改变它所指向的整型值；int * const

p2声明了一个指针型常量，用于存放整型变量的地址，这个指针一旦初始化后，就不能被重新赋值了。

6-16 定义一个整型变量a，一个整型指针p，一个引用r，通过p把a的值改为10，通过r 把a的值改为5

解：

void main()

{

int a;

int *p = &a;

int &r = a;

*p = 10;

r = 5;

}

6-17 下列程序有何问题，请仔细体会使用指针时应避免出现这个的问题。

#include

int main()

int *p;

*pInt = 9;

cout << "The value at p: " << *p;

return 0;

}

解：

指针p没有初始化，也就是没有指向某个确定的内存单元，它指向内存中的一个随机地址，给这个随机地址赋值是非常危险的。

6-18 下列程序有何问题，请改正；仔细体会使用指针时应避免出现的这个问题。

#include

int Fn1();

int main()

{

int a = Fn1();

cout << "the value of a is: " << a;

return 0;

}

int Fn1()

{

int * p = new int (5);

return *p;

}

解：

此程序中给*p分配的内存没有被释放掉。

改正：

#include

int* Fn1();

int main()

{

int *a = Fn1();

cout << "the value of a is: " << *a;

delete a;

return 0;

}

int* Fn1()

{

int * p = new int (5);

return p;

}

6-19 声明一个参数为整型，返回值为长整型的函数指针；声明类A的一个成员函数指针，其参数为整型，返回值长整型。

long (* p_fn1)(int);

long ( A::*p_fn2)(int);

6-20 实现一个名为SimpleCircle的简单圆类，其数据成员int *itsRadius为一个指向其半径值的指针，设计对数据成员的各种操作，给出这个类的完整实现并测试这个类。

解：

源程序：

#include

class SimpleCircle

{

public:

SimpleCircle();

SimpleCircle(int);

SimpleCircle(const SimpleCircle &);

~SimpleCircle() {}

void SetRadius(int);

int GetRadius()const;

private:

int *itsRadius;

};

SimpleCircle::SimpleCircle()

{

itsRadius = new int(5);

}

SimpleCircle::SimpleCircle(int radius)

{

itsRadius = new int(radius);

}

SimpleCircle::SimpleCircle(const SimpleCircle & rhs)

{

int val = rhs.GetRadius();

itsRadius = new int(val);

}

int SimpleCircle::GetRadius() const

{

return *itsRadius;

}

int main()

{

SimpleCircle CircleOne, CircleTwo(9);

cout << "CircleOne: " << CircleOne.GetRadius() << endl;

cout << "CircleTwo: " << CircleTwo.GetRadius() << endl;

}程序运行输出：

CircleOne: 5

CircleTwo: 9

6-21 编写一个函数，统计一个英文句子中字母的个数，在主程序中实现输入、输出。

解：

源程序：

#include

#include

int count(char *str)

{

int i,num=0;

for (i=0; str[i]; i++)

{

if ( (str[i]>='a' && str[i]<='z') || (str[i]>='A' && str[i]<='Z') )

num++;

}

return num;

}

void main()

{

char text[100];

cout << "输入一个英语句子：" << endl;

gets(text);

cout << "这个句子里有" << count(text) << "个字母。" << endl;

}

程序运行输出：

输入一个英语句子：

It is very interesting!

这个句子里有19个字母。

6-22 编写函数reverse(char *s)的倒序递归程序，使字符串s倒序。

解：

源程序：

#include

#include

void reverse(char *s, char *t)

{

char c;

if (s < t)

{

c = *s;

*t = c;

reverse(++s, --t);

}

}

void reverse( char *s)

{

reverse(s, s + strlen(s) - 1);

}

void main()

{

char str1[20];

cout << "输入一个字符串：";

cin >> str1;

cout << "原字符串为：" << str1 << endl;

reverse(str1);

cout << "倒序反转后为：" << str1 << endl;

}

程序运行输出：

输入一个字符串：abcdefghijk

原字符串为：abcdefghijk

倒序反转后为：kjihgfedcba

6-23 设学生人数N=8，提示用户输入N个人的考试成绩，然后计算出平均成绩，显示出来。

解：

源程序：

#include

#include

#define N 8

float grades[N]; //存放成绩的数组

void main()

{

int i;

float total,average;

//提示输入成绩

for(i = 0; i < N; i++ )

{

cout << "Enter grade #" <<(i +1) << ": ";

cin >> grades[i];

}

total = 0;

for (i = 0; i < N; i++)

total += grades[i];

cout << "\nAverage grade: " << average << endl;

}

程序运行输出：

Enter grade #1: 86

Enter grade #2: 98

Enter grade #3: 67

Enter grade #4: 80

Enter grade #5: 78

Enter grade #6: 95

Enter grade #7: 78

Enter grade #8: 56

Average grade: 79.75

6-24

设计一个字符串类MyString，具有构造函数、析构函数、拷贝构造函数，重载运算符+、=、+=、[]，尽可能地完善它，使之能满足各种需要。（运算符重载功能为选做，参见第8章）

解：

#include

#include

class MyString

{

public:

MyString();

MyString(const char *const);

MyString(const MyString &);

~MyString();

char & operator[](unsigned short offset);

char operator[](unsigned short offset) const;

MyString operator+(const MyString&);

void operator+=(const MyString&);

MyString & operator= (const MyString &);

unsigned short GetLen()const { return itsLen; }

const char * GetMyString() const { return itsMyString; }

private:

MyString (unsigned short); // private constructor

char * itsMyString;

unsigned short itsLen;

};

MyString::MyString()

{

itsMyString = new char[1];

itsMyString[0] = '\0';

itsLen=0;

}

{

itsMyString = new char[len+1];

for (unsigned short i = 0; i<=len; i++)

itsMyString[i] = '\0';

itsLen=len;

}

MyString::MyString(const char * const cMyString) {

itsLen = strlen(cMyString);

itsMyString = new char[itsLen+1];

for (unsigned short i = 0; i

itsMyString[i] = cMyString[i];

itsMyString[itsLen]='\0';

}

MyString::MyString (const MyString & rhs)

{

itsLen=rhs.GetLen();

itsMyString = new char[itsLen+1];

for (unsigned short i = 0; i

itsMyString[i] = rhs[i];

itsMyString[itsLen] = '\0';

}

MyString::~MyString ()

{

delete [] itsMyString;

itsLen = 0;

}

MyString& MyString::operator=(const MyString & rhs) {

if (this == &rhs)

return *this;

delete [] itsMyString;

itsLen=rhs.GetLen();

itsMyString = new char[itsLen+1];

for (unsigned short i = 0; i

itsMyString[i] = rhs[i];

itsMyString[itsLen] = '\0';

return *this;

}

char & MyString::operator[](unsigned short offset) {

if (offset > itsLen)

return itsMyString[itsLen-1];

else

return itsMyString[offset];

char MyString::operator[](unsigned short offset) const {

if (offset > itsLen)

return itsMyString[itsLen-1];

else

return itsMyString[offset];

}

MyString MyString::operator+(const MyString& rhs) {

unsigned short totalLen = itsLen + rhs.GetLen(); MyString temp(totalLen);

for (unsigned short i = 0; i

temp[i] = itsMyString[i];

for (unsigned short j = 0; j

temp[totalLen]='\0';

return temp;

}

void MyString::operator+=(const MyString& rhs) {

unsigned short rhsLen = rhs.GetLen();

unsigned short totalLen = itsLen + rhsLen; MyString temp(totalLen);

for (unsigned short i = 0; i

temp[i] = itsMyString[i];

for (unsigned short j = 0; j

temp[totalLen]='\0';

*this = temp;

}

int main()

{

MyString s1("initial test");

cout << "S1:\t" << s1.GetMyString() << endl;

char * temp = "Hello World";

s1 = temp;

cout << "S1:\t" << s1.GetMyString() << endl;

char tempTwo[20];

strcpy(tempTwo,"; nice to be here!");

s1 += tempTwo;

cout << "tempTwo:\t" << tempTwo << endl;

cout << "S1:\t" << s1.GetMyString() << endl;

cout << "S1[4]:\t" << s1[4] << endl;

s1[4]='x';

cout << "S1:\t" << s1.GetMyString() << endl;

MyString s2(" Another myString");

MyString s3;

s3 = s1+s2;

cout << "S3:\t" << s3.GetMyString() << endl;

MyString s4;

s4 = "Why does this work?";

cout << "S4:\t" << s4.GetMyString() << endl;

return 0;

}

程序运行输出：

S1: initial test

S1: Hello World

tempTwo: ; nice to be here!

S1: Hello World; nice to be here!

S1[4]: o

S1: Hellx World; nice to be here!

S1[999]: !

S3: Hellx World; nice to be here! Another myString

S4: Why does this work?

6-25编写一个3×3矩阵转置的函数，在main()函数中输入数据。

解：

#include

void move (int matrix[3][3])

{

int i, j, k;

for(i=0; i<3; i++)

for (j=0; j

{

k = matrix[i][j];

matrix[i][j] = matrix[j][i];

matrix[j][i] = k;

}

}

void main()

{

int i, j;

int data[3][3];

cout << "输入矩阵的元素" << endl;

for(i=0; i<3; i++)

for (j=0; j<3; j++)

{

cout << "第" << i+1 << "行第" << j+1

<<"个元素为：";

cout << "输入的矩阵的为：" << endl;

for(i=0; i<3; i++)

{

for (j=0; j<3; j++)

cout << data[i][j] << " ";

cout << endl;

}

move(data);

cout << "转置后的矩阵的为：" << endl;

for(i=0; i<3; i++)

{

for (j=0; j<3; j++)

cout << data[i][j] << " ";

cout << endl;

}

}

程序运行输出：

输入矩阵的元素

第1行第1个元素为：1

第1行第2个元素为：2

第1行第3个元素为：3

第2行第1个元素为：4

第2行第2个元素为：5

第2行第3个元素为：6

第3行第1个元素为：7

第3行第2个元素为：8

第3行第3个元素为：9

输入的矩阵的为：

1 2 3

4 5 6

7 8 9

转置后的矩阵的为：

1 4 7

2 5 8

3 6 9

6-26 编写一个矩阵转置的函数，矩阵的维数在程序中由用户输入。

解：

#include

void move (int *matrix ,int n)

{

int i, j, k;

for(i=0; i

k = *(matrix + i*n + j);

*(matrix + i*n + j) = *(matrix + j*n + i); *(matrix + j*n + i) = k;

}

}

void main()

{

int n, i, j;

int *p;

cout << "请输入矩阵的维数：";

cin >> n;

p = new int[n*n];

cout << "输入矩阵的元素" << endl;

for(i=0; i

for (j=0; j

{

cout << "第" << i+1 << "行第" << j+1

<<"个元素为：";

cin >> p[i*n + j];

}

cout << "输入的矩阵的为：" << endl; for(i=0; i

{

for (j=0; j

cout << p[i*n + j] << " ";

cout << endl;

}

move(p, n);

cout << "转置后的矩阵的为：" << endl; for(i=0; i

{

for (j=0; j

cout << p[i*n + j] << " ";

cout << endl;

}

}

程序运行输出：

请输入矩阵的维数：3

输入矩阵的元素

第1行第1个元素为：1

第1行第2个元素为：2

第1行第3个元素为：3

第2行第1个元素为：4

第2行第2个元素为：5

第3行第1个元素为：7

第3行第2个元素为：8

第3行第3个元素为：9

输入的矩阵的为：

1 2 3

4 5 6

7 8 9

转置后的矩阵的为：

1 4 7

2 5 8

3 6 9

6-27

定义一个Employee类，其中包括表示姓名、街道地址、城市和邮编等属性，包括chage_name()和display()等函数；display()使用cout语句显示姓名、街道地址、城市和邮编等属性，函数change_name()改变对象的姓名属性，实现并测试这个类。

解：

源程序：

#include

#include

class Employee

{

private:

char name[30];

char street[30];

char city[18];

char zip[6];

public:

Employee(char *n, char *str, char *ct, char *z);

void change_name(char *n);

void display();

};

Employee::Employee (char *n,char *str,char *ct, char *z)

{

strcpy(name, n);

strcpy(street, str);

strcpy(city, ct);

strcpy(zip, z);

}

void Employee::change_name (char *n)

{

strcpy(name, n);

}

void Employee::display ()

cout << name << " " << street << " ";

cout << city << " "<< zip;

}

void main(void)

{

Employee e1("张三","平安大街3号", "北京", "100000"); e1.display();

cout << endl;

e1.change_name("李四");

e1.display();

cout << endl;

}

程序运行输出：

张三平安大街3号北京100000

李四平安大街3号北京100000

C语言程序设计实验答案数组、指针与字符串

实验06 数组、指针与字符串（4学时） （第6章数组、指针与字符串） 一、实验目的 二、实验任务 6_1（习题6-25）编写并测试3×3矩阵转置函数，使用数组保存3×3矩阵。 6_2（习题6-26）使用动态内存分配生成动态数组来重新完成上题（n阶方阵），使用指针实现函数的功能。 6_3 编程实现两字符串的连接。要求使用字符数组保存字符串，不要使用系统函数。 6_4 使用string类声明字符串对象，重新实现上一小题。 6_5（习题6-27）声明一个Employee类。 其中包括姓名、街道地址、城市和邮编等属性，以及change_name()和display()等函数。display()显示姓名、街道地址、城市和邮编等属性，change_name()改变对象的姓名属性，实现并测试这个类。 6_6（习题6-27）声明包含5个元素的对象数组，每个元素都是Employee 类型的对象。 6_7 修改实验4中的people（人员）类。 具有的属性如下：姓名char name[11]、编号char number[7]、性别char sex[3]、生日birthday、身份证号char id[16]。其中“出生日期”声明为一个“日期”类内嵌子对象。 用成员函数实现对人员信息的录入和显示。 要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、聚集。 在测试程序中声明people类的对象数组，录入数据并显示。

三、实验步骤 1.（编程，习题6-25）编写矩阵转置函数，输入参数为3×3整型数组。 使用循环语句实现矩阵元素的行列对调，注意在循环语句中究竟需要对哪些元素进行操作，编写main()函数实现输入输出。程序名：lab6_1.cpp。 参考运行结果： ★程序及运行结果： //lab6_1.cpp #include using namespace std; void move(int matrix[][3]){ int temp; for(int i=0;i<3;i++) for(int j=0;j>mat[i][j]; } cout<<"\n输入的3×3矩阵为："<

指针数组及指向一维数组的指针讲解

一、指针数组及指向一维数组的指针（数组指针）讲解 1、数组指针（也称行指针） 定义 int (*p)[n]; ()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。 如要将二维数组赋给一指针，应这样赋值：int a[3][4];int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。 p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0] p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][] 所以数组指针也称指向一维数组的指针，亦称行指针。 2、指针数组 定义 int *p[n]; []优先级高，先与p结合成为一个数组，再由int *说明这是一个整型指针数组，它有n个指针类型的数组元素。这样赋值是错误的：p=a；只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。 如要将二维数组赋给一指针数组: int *p[3]; int a[3][4]; for(i=0;i<3;i++) p[i]=a[i]; 这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p [1]、p[2]所以要分别赋值。 这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。 还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。 比如要表示数组中i行j列一个元素： *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j] 优先级：()>[]>* 例1、下列给定程序中，函数fun()的功能是：从N个字符串中找出最长的那个串，并将其地址作为函数值返回。 #include #include #define N 4

C语言字符串指针问题

C语言字符串指针问题 在C语言中，可以用两种方法访问一个字符串。 用字符数组存放一个字符串，然后输出该字符串。 1.main(){ 2.char string[]=”I love China!”; 3.printf("%s\n",string); 4.} 说明：和前面介绍的数组属性一样，string是数组名，它代表字符数组的首地址。 用字符串指针指向一个字符串。 1.main(){ 2.char *string=”I love China!”;

3.printf("%s\n",string); 4.} 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c; 表示p是一个指向字符变量c的指针变量。而： char *s="C Language"; 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。 上例中，首先定义string是一个字符指针变量，然后把字符串的首地址赋予string（应写出整个字符串，以便编译系统把该串装入连续的一块内存单元），并把首地址送入string。程序中的：char *ps="C Language"; 等效于： char *ps; ps="C Language"; 输出字符串中n个字符后的所有字符。 1.main(){ 2.char *ps="this is a book";

3.int n=10; 4.ps=ps+n; 5.printf("%s\n",ps); 6.} 运行结果为： book 在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。 在输入的字符串中查找有无‘k’字符。 1.main(){ 2.char st[20],*ps; 3.int i; 4.printf("input a string:\n"); 5.ps=st; 6.scanf("%s",ps); 7.for(i=0;ps[i]!='\0';i++) 8.if(ps[i]=='k'){ 9.printf("there is a 'k' in the string\n"); 10.break; 11.} 12.if(ps[i]=='\0') printf("There is no 'k' in the string\n");

指向指针的指针——彻底搞定C指针

彻底搞定C指针---指向指针的指针 彻底搞定C指针---指向指针的指针一．回顾指针概念： 今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧！ 当我们程序如下申明变量： short int i; char a; short int * pi; 程序会在内存某地址空间上为各变量开辟空间，如下图所示。 内存地址→6 7 8 9 10 11 12 13 14 15 ------------------------------------------------------------------------------------- … | | | | | | | | | | ------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 图中所示中可看出： i 变量在内存地址5的位置，占两个字节。 a变量在内存地址7的位置，占一个字节。 pi变量在内存地址9的位置，占两个字节。(注：pi 是指针，我这里指针的宽度只有两个字节，32位系统是四个字节) 接下来如下赋值: i=50; pi=&i; 经过上在两句的赋值，变量的内存映象如下: 内存地址→6 7 8 9 10 11 12 13 14 15 -------------------------------------------------------------------------------------- … | 50 | | | 6 | | | | -------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 看到没有：短整型指针变量pi的值为6，它就是I变量的内存起始地址。所以，这时当我们对*pi进行读写操作时，其实就是对i变量的读写操作。如：*pi=5; //就是等价于I=5; 你可以回看本系列的第二篇，那里有更加详细的解说。 二．指针的地址与指向另一指针地址的指针 在上一节中，我们看到，指针变量本身与其它变量一样也是在某个内存地址中的，如pi的内存起始地址是10。同样的，我们也可能让某个指针指向这个

C语言中指针、数组和引用例子实例

一、指针：内容是指示一个内存地址的变量；类型是指示编译器怎么解释指针内容指向地址中的内容，以及该内存区域有多大； 例子： [cpp] int i = 0; int * pi = &i; printf(“pi = %x \n”, pi); // 打印pi的内容: 0x2000 printf(“*pi= %d \n” , *pi); // 打印pi指向地址中的值: 5 printf(“&pi= %x \n”, &pi); // 打印pi的地址: 0x100 从汇编的角度来看，指针是这样的： int i = 0; 010E139E mov dword ptr [i],0 int * pi = &i; 010E13A5 lea eax,[i] 010E13A8 mov dword ptr [pi],eax 二、数组：是一个单一数据类型对象的集合。其中单个对象没有被命名，通过索引访问。 数组名和指针的区别：数组名的内涵在于其指代实体是一种数据结构，这种数据结构就是数组。数组名的外延在于其可以转换为指向其指代实体的指针，而且是一个指针常量。指向数组的指针则是另外一种变量类型，仅仅意味着数组的存放地址 注意：虽然数组名可以转换为指向其指代实体的指针，但是它只能被看作一个指针常量，不能被修改，如下：天骄无双：https://www.doczj.com/doc/ce11872710.html, [cpp] int intArray[10]; intArray++; // 错误 “指针和数组等价”说的是什么？索引操作相同，例如：p[2]; a[2]; 三、引用（reference）是一个对象的别名。用对象初始化引用后，对象的名字和引用都指向该对象； 引用是如何实现的？从汇编语言的角度来看，指针和引用是一样的： [cpp] int i = 0; 00E9139E mov dword ptr [i],0 int & ref = i; 00E913A5 lea eax,[i] 00E913A8 mov dword ptr [ref],eax int * pi = &i; 00E913AB lea eax,[i] 00E913AE mov dword ptr [pi],eax 指针和引用的区别（从C++使用角度来看）： 不存在空引用 引用要初始化 引用初始化后，不能指向另一个对象 这是由编译阶段保证的。 备注：一个指向非常量的引用不能用字面值或者临时值初始化；但是一个指向常量的引用可以。天骄无双：https://www.doczj.com/doc/ce11872710.html,

C语言字符串的输入和输出

C语言字符串的输入和输出 字符串的输入和输出 %c人为加入\0进行输入输出 %s直接输入输出 *输入输出字符串时字符数组应有足够的存储空间，指针变量作为输入项时，指针必须已经指向确切的、足够大的存储空间 %s的使用 scanf("%s",地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 例:char str[15]; scanf("%s",str); abc123 1.不读入空格和回车,从空格处结束 2.输入字符串长度超过字符数组元素个数，不报错 3.当输入项为字符指针时，指针必须已指向确定的有足够空间的连续 存储单元 4.当为数组元素地址时，从此元素地址开始存放 2.printf("%s",地址值) 输出时遇到第一个'\0'为止 3.gets和puts函数 开头必须stdio.h #include"stdio.h"

1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 4.当为数组元素地址时，从此元素地址开始存放 5.printf("%s",地址值) 输出时遇到第一个'\0'为止 6.gets和puts函数 开头必须stdio.h #include"stdio.h" 1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 7.例: char str[10]; gets(str); 包括空格符 8. 2.puts(字符串起始地址) 遇第一个'\0'结束,自动加入换行符 9.字符串数组:数组中每个元素都是一个存放字符串的数组 可以将一个二维数组看作是字符串数组 10.char ca[3][5]={"A","BB","CCC"}; A\0 B B\0 C C C\0 字符型指针数组 char*pa[3]={"a","bb","ccc"}; pa[0]pa[1]pa[2] 可以重新赋值gets(pa[2]);

指向二维数组的指针

指向二维数组的指针 一. 二维数组元素的地址 为了说明问题, 我们定义以下二维数组: int a[3][4]={{0,1,2,3}, {4,5,6,7}, {8,9,10,11}}; a为二维数组名, 此数组有3行4列, 共12个元素。但也可这样来理解, 数组a由三个元素组成: a[0], a[1], a[2]。而它中每个元素又是一个一维数组, 且都含有4个元素(相当于4列), 例如, a[0]所代表的一维数组所包含的 4 个元素为a[0][0], a[0][1], a[0][2], a[0][3]。如图5.所示: ┏━━━━┓┏━┳━┳━┳━┓ a─→ ┃a[0] ┃─→┃0 ┃1 ┃2 ┃3 ┃ ┣━━━━┫┣━╋━╋━╋━┫ ┃a[1] ┃─→┃4 ┃5 ┃6 ┃7 ┃ ┣━━━━┫┣━╋━╋━╋━┫ ┃a[2] ┃─→┃8 ┃9 ┃10┃11┃ ┗━━━━┛┗━┻━┻━┻━┛ 图5. 但从二维数组的角度来看, a代表二维数组的首地址, 当然也可看成是二维数组第0行的首地址。a+1就代表第1行的首地址, a+2就代表第2行的首地址。如果此二维数组的首地址为1000, 由于第0行有4个整型元素, 所以a+1为1008, a+2 也就为1016。如图6.所示 a[3][4] a ┏━┳━┳━┳━┓ (1000)─→┃0 ┃1 ┃2 ┃3 ┃ a+1 ┣━╋━╋━╋━┫ (1008)─→┃4 ┃5 ┃6 ┃7 ┃ a+2 ┣━╋━╋━╋━┫ (1016)─→┃8 ┃9 ┃10┃11┃ ┗━┻━┻━┻━┛ 图6. 既然我们把a[0], a[1], a[2]看成是一维数组名, 可以认为它们分别代表它们所对应的数组的首地址, 也就是讲, a[0]代表第0 行中第0 列元素的地址, 即&a[0][0], a[1]是第1行中第0列元素的地址, 即&a[1][0], 根据地址运算规则, a[0]+1即代表第0行第1列元素的地址, 即&a[0][1], 一般而言, a[i]+j即代表第i行第j列元素的地址, 即&a[i][j]。 另外, 在二维数组中, 我们还可用指针的形式来表示各元素的地址。如前所述, a[0]与*(a+0)等价, a[1]与*(a+1)等价, 因此a[i]+j就与 *(a+i)+j等价, 它表示数组元素a[i][j]的地址。 因此, 二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j), 它们都与a[i][j]等价, 或者还可写成(*(a+i))[j]。 另外, 要补充说明一下, 如果你编写一个程序输出打印a和*a, 你可发现它们的值是相同的, 这是为什么呢? 我们可这样来理解: 首先, 为了说明问题, 我们把二维数组人为地看成由三个数组元素a[0], a[1], a[2]组成, 将a[0], a[1], a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此, a表示数组第0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址, 它就是数组第0 行第0 列元素的地址。 二. 指向一个由n个元素所组成的数组指针 在Turbo C中, 可定义如下的指针变量: int (*p)[3]; 指针p为指向一个由3个元素所组成的整型数组指针。在定义中, 圆括号是不能少的, 否则它是指针数组, 这将在后面介绍。这种数组的指针不同于前面介绍的整型指针, 当整型指针指向一个整型数组的元素时, 进行指针(地址)加1运算, 表示指向数组的下一个元素, 此时地址值增加了2(因为放大因子为2),而如上所定义的指向一个由3个元素组成的数组指针, 进行地址加1运算时, 其地址值增加了6(放大因子为2x3=6), 这种数组指针在Turbo C中用得较少, 但在处理二维数组时, 还是很方便的。例如:

第七章字符数组与指针练习题参考答案

第七章字符数组与字符串 【题7.29】下面是对s的初始化，其中不正确的是。 A）char s[5]={“abc”};B）char s[5]={‘a’,‘b’,‘c’}; C）char s[5]=“”;D）char s[5]=“abcdef”; 【题7.30】下面程序段的运行结果是。 char c[5]={‘a’,‘b’,‘\0’,‘c’,‘\0’}; printf(“%s”,c); A）‘a’‘b’ B）ab C）ab c 【题7.31】对两个数组a和b进行如下初始化 char a[]=“ABCDEF”; char b[]={‘A’, ‘B’,‘C’,‘D’,‘E’,‘F’}; 则以下叙述正确的是。 A）a与b数组完全相同B）a与b长度相同 C）a和b中都存放字符串D）a数组比b数组长度长 提示：‘\0’是字符串结束的标志 【题7.32】有两个字符数组a、b，则以下正确的输入格式是。 A）gets(a,b); B）scanf(“%s %s”,a,b); C）scanf(“%s %s”,&a,&b);D）gets(“a”),get(“b”); 【题7.33】有字符数组a[80]和b[80]，则正确的输出形式是。 A）puts(a,b); B）printf(“%s %s”,a[],b[]); C）putchar(a,b); D）puts(a),puts(b); 【题7.34】下面程序段的运行结果是。 char a[7]=“abcdef”; char b[4]=“ABC”; strcpy(a,b); printf(“%c”,a[5]); A）空格B）\0 C）e D）f 提示：复制后a[0]=‘A’,a[1]=‘B’,a[2]=‘C’,a[3]=‘\0’, a[4]=‘e’,a[5]=‘f’, a[6]=‘\0’,

关于二维数组和指向指针的指针

以前一直有种误解： 二维数组的是数组的数组，所以数组的首地址是指向第一个元素指针，而这个元素又是一个数组，所以把数组首地址理解为指向指针的指针。 如int a[3][2];，以前一直认为a是一个指向int指针的指针，即是一个int**。最近发现这是错的。 如果int **p=a; 编译就会报错。如果强制转换int **p=(int **)a，则使用p[i][j]访问数组元素时出错。 首先，因为a的定义为int a[3][2];则a的类型是int* [3][2]数组类型，或者int* [][2],即指向大小为2的数组的指针，类型与int **不同，所以int **p=a;出错。 其次，考虑p[i][j]访问a的数组元素时出错的问题。当我们使用指向二维数组的指针的下标运算来访问数组元素时，如a[i][j]，它等同于*(a+i*2+j);即必须要知道第二维的大小才能访问。考虑我使用p[i][j]的后果：p是int**，所以p[i]为*(p+i)，而这个结果被视作一个指针，在这里记做pp＝*(p+i)，所以p[i][j]等同于pp[j]。最终的结果为*(pp+j)，并将这个结果解释为一个int值。 int a[3][2]; int val=0; for(int i=0;i<3;++i) { for(int j=0;j<2;++j) { a[i][j]=val++; } } /*使用a[i][j]的方式显然可以正常访问该二维数组*/ /*下面使用指针直接访问，当然是不是int**了……*/ int *p=&a[0][0];/*注意，此处使用int *p=a;或者int *p=a[0];是不对的，p的类型是int型指针，*a或者a[0]是int (*)[2]类型，编译会报错的，* *尽管&a[0][0]、a、a[0]的数值相同……*/ for(int i=0;i<6;++i) { p[i];/*这样可以遍历所有元素*/ }

C语言指针习题__附答案[1]

一、选择题 1.变量的指针，其含义是指该变量的_________. a)值b)地址 c)名d)一个标志 2．若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是_____. a)a,point,*&a b)&*a,&a,*point c)*&point,*point,&a d)&a,&*point ,point 3．若有说明;int *p,m=5,n;以下正确的程序段的是________. a)p=&n; b)p=&n; scanf("%d",&p); scanf("%d",*p); c)scanf("%d",&n); d)p=&n; *p=n; *p=m; 4. 以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是________. main() { int *p,*q,a,b; p=&a; printf(“input a:”); scanf(“%d”,*p); …… } a)*p表示的是指针变量p的地址 b)*p表示的是变量a的值，而不是变量a的地址 c)*p表示的是指针变量p的值 d)*p只能用来说明p是一个指针变量 5. 已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是________. void print_value(int *x) { printf(“%d\n”,++*x);} a)23 b)24 c)25 d)26 6.若有说明：long *p,a;则不能通过scanf语句正确给输入项读入数据的程序段是 A) *p=&a；scanf("%ld"，p)；

指向字符串的指针数组

在初学习C语言时，对于指针是最容易让人迷糊的，尤其对于指针数组，而且是指向字符串的指针数组，恐怕就更难理解了。下面本人给出一个例子，详细讲解指向字符串的指针数组的使用情况。希望给予学习C的朋友一点帮助。 下述程序执行后，输出结果是什么？ #include char *p[2][3]={ "abc","defgh","ijkl","mnopqr","stuvw","xyz"}; main(){ printf("%c\n",***(p+1)); printf("%c\n",**p[0]); printf("%c\n",(*(*(p+1)+1))[4]); printf("%c\n",*(p[1][2]+2)); printf("%s\n",**(p+1)); } 答案是： m a w z mnopqr 答案解析： 这里相当于定义了2行3列共6个元素的数组，数组的每一个元素都是指向字符的指针变量。 其中p[0][0]指向串"abc"，p[0][1]指向串"defgh"，p[0][2] 指向串"ijkl"，p[1][0]指向串"mnopqr"，p[1][1]指向串"stuvw"，p[1][2] 指向串"xyz"。 1、printf("%c\n",***(p+1)); 这里的***(p+1)相当于*(*(*(p+1)+0)+0)，而*(*(p+1)+0)+0)的另一种容易懂的形式是p[1][0]，在多维数组中这两种写法等价。如上面所写的p[1][0]是指向串"mnopqr"，即保存的是串"mnopqr"的首地址，也即字母m的地址。因此***(p+1)是字母m 2、printf("%c\n",**p[0]); 这里的**p[0]等价于*(*(*(p+0)+0)+0)，也即*（p[0][0]），而p[0][0]）指向串"abc"，所以*（p[0][0]）是字符a 3、printf("%c\n",(*(*(p+1)+1))[4]); (*(*(p+1)+1))[4]等价于*（（p[1][1]）+4），而（p[1][1]）指向串"stuvw"，所以*（（p[1][1]）+4）是在串首向后移动4个单位的字符，也即w 4、printf("%c\n",*(p[1][2]+2)); 因为p[1][2]指向串"xyz"，而p[1][2]+2 就是串首向后移动2个字节（一个字节保存一个字符），也就是指向字符z,所以*(p[1][2]+2)是字符z

指针经典练习题及答案

二、程序题 1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。 2、加密程序:由键盘输入明文，通过加密程序转换成密文并输出到屏幕上。 算法：明文中的字母转换成其后的第4个字母,例如，A变成E(a变成e)， Z变成D,非字母字符不变；同时将密文每两个字符之间插入一个空格。 例如，China转换成密文为G l m r e。 要求：在函数change中完成字母转换，在函数insert中完成增加空格， 用指针传递参数。 3、字符替换。要求用函数replace将用户输入的字符串中的字符t(T)都替换为e(E)， 并返回替换字符的个数。 4、编写一个程序，输入星期，输出该星期的英文名。用指针数组处理。 5、有5个字符串，首先将它们按照字符串中的字符个数由小到大排列， 再分别取出每个字符串的第三个字母合并成一个新的字符串输出 （若少于三个字符的输出空格）。要求：利用字符串指针和指针数组实现。 6、定义一个动态数组，长度为变量n，用随机数给数组各元素赋值， 然后对数组各单元排序，定义swap函数交换数据单元，要求参数使用指针传递。7、实现模拟彩票的程序设计：随机产生6个数字，与用户输入的数字进行比较， 输它们相同的数字个数（使用动态内存分配）。 /*1、计算字符串中子串出现的次数。要求:用一个子函数subString()实现, 参数为指向字符串和要查找的子串的指针,返回次数。*/ #include int subString(char *a, char *b) { int i = 0; int j = 0; int m = 0; char *p = b; while(*a) { while(*a) { if(*a == *b) { break; } a++; } while(*b) { if(*a != *b)

字符数组,字符指针,sizeof,strlen总结

[cpp] 字符数组,字符指针,sizeof,strlen总结 作者：Hui Wang来源：博客园发布时间：2011-03-26 14:22 阅读：728 次原文链接[收藏]对于字符数组与字符指针: 1. 以字符串形式出现的，编译器都会为该字符串自动添加一个0作为结束符，如在代码中写"abc",那么编译器帮你存储的是"abc\0". 2. 字符串直接量作为字符指针的初始值 ＂hello＂是一个字符串直接量，编译器将其作为const char*处理，与之相关联的内存空间位于内存的只读部分，即允许编译器重用指向等价字符串直接量的引用以优化内存使用， 即使程序中使用了字符串直接量500次，编译器在内存中也只是创建了一个实例。例如: char *ptr = “hello”; 等价于const char *ptr = “hello”; 字符串直接量＂hello＂关联的是只读内存，如果试图修改将出错，例如ptr[1] = …a?;是会引起错误的。 3. 字符串直接量作为基于栈的字符数组的初始值 由于基于栈的变量不可能引用其他地方存储的内存，编译器会负责将字符串直接量复制到基于栈的数组内存中。 例如: char stackArray[] = “hello”; 做如下修改: stackArray[1] = …a?;是真确的。 4. 字符数组与字符指针 字符数组的形式如下,会将字符直接量拷贝到栈上: char str[] = "abc"; // 实际的数据存储: a b c \0,也就是增加了一个终结符\0 char str[3] = {'a','b','c'}; // 实际的数据存储: a b c,并没有在最后添加终结符 char str[10] = {'a','b','c'}; // 实际的数据存储: a b c \0 \0 \0 \0 \0 \0 \0 字符指针的形式如下: char *str = “abc”;// 实际的数据存储: a b c \0,也就是增加了一个终结符\0 5. 类型的决定 1). 数组的类型是由该数组所存放元素的类型以及数组本身的大小决定的 如char s1[3]和char s2[4]，s1的类型就是char[3]，s2的类型就是char[4]，也就是说尽管s1和s2都是字符数组，但两者的类型却是不同的。 2). 字符串常量的类型可以理解为相应字符常量数组的类型 如"abcdef"的类型就可以看成是const char[7],也就是说实际的数据存储为"abcdef\0"。 3). 函数参数列表中的以数组类型书写的形式参数,编译器把其解释为普通的指针类型

C语言指针数组和数组指针

C语言指针数组和数组指针 一、指针数组和数组指针的内存布局 初学者总是分不出指针数组与数组指针的区别。其实很好理解： 指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。 数组指针：首先它是一个指针，它指向一个数组。在32 位系统下永远是占4 个字节，至于它指向的数组占多少字节，不知道。它是“指向数组的指针”的简称。 下面到底哪个是数组指针，哪个是指针数组呢： A) int *p1[10]; B) int (*p2)[10]; 每次上课问这个问题，总有弄不清楚的。这里需要明白一个符号之间的优先级问题。 “[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。至于p2 就更好理解了，在这里“（）”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。我们可以借助下面的图加深理解：

二、int (*)[10] p2-----也许应该这么定义数组指针 这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么？这个指针p2 的定义怎么不是按照这个语法来定义的呢？也许我们应该这样来定义p2： int (*)[10] p2; int (*)[10]是指针类型，p2 是指针变量。这样看起来的确不错，不过就是样子有些别扭。其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。你私下完全可以这么理解这点。虽然编译器不这么想。^_^ 三、再论a 和&a 之间的区别 既然这样，那问题就来了。前面我们讲过a 和&a 之间的区别，现在再来看看下面的代码： int main() { char a[5]={'A','B','C','D'}; char (*p3)[5] = &a; char (*p4)[5] = a; return 0;

第8章 指针-3字符数组和字符指针 - 字符串的表示与存储

第8章指针——字符数组与字符指针：字符串的表示与存储

printf("How are you"); H o w a r e y o u \0

printf("How are you.\n "); printf("\"How are you.\"\n"); How are you. _ printf("How are you. Press \ a key and then press Enter:\n"); How are you. Press a key and then press Enter: _ "How are you." _ printf("How are you. Press " "a key and then press Enter:\n"); 问题：如果字符串太长，怎么表示？

?C语言没有提供专门的字符串数据类型 ?字符数组——每个元素都是字符类型的数组 H o w a r e y o u 0 H o w a r e y o u \0

?字符数组的定义 #define STR_LEN 80 char str[STR_LEN+1]; ?字符数组的初始化 用字符常量的初始化列表对数组初始化 char str[6] = {'C','h','i','n','a','\0'}; 用字符串常量直接对数组初始化 char str[6] = {"China"}; char str[6] = "China"; char str[ ] = "China"; char char str[10] = "China";

?字符指针就是指向字符串首地址的指针 ?定义一个字符指针，使其指向一个字符串常量 H e l l o C h i n a \0

力控数组指针的实现

：《再问如何把一个变量的采样值保存到一个数组中呢》本论题共有134人阅读，有4人回复。 我设计了一个循环，每隔一定时间把变量值赋给一个中间变量，但是发现这个数组的每个元素都是一样的值，不知是怎么回事？该如何解决呢? tmp为间接变量 WHILE(t<=15) DO t=t+1; tmp[t]=uc.PV; Delay(100); ENDWHILE yz 以下是对《再问如何把一个变量的采样值保存到一个数组中呢》的回复：111 sunwaywell

VarRedir(DbVar,"t" + IntToStr(i, 10) + ".pv"); DbVar = i; NEXT 这个循环结束后，可以看到t1 - t15都赋值完成了。 关于循环中用到的函数VarRedir，说明如下（详见力控联机帮助）： VarRedir 数据库变量重定向。 语法 VarRedir(var, NewTagPar) 说明 用于将数据库变量或间接变量重定向，对于数据库变量改变变量的数据库参数名称，使其指向其他数据库参数；而对于间接变量则改变其变量指向，使其指向名字为 NewTagPar的变量，该变量在DRAW中一定要存在。 通常可用于历史报表，趋势中变量动态替换。 参数 var: 重定向变量，该变量必须为数据库变量或间接变量。 NewTagPar:字符串类型，新数据库参数或变量名称名称。 示例 VarRedir(dbvar1, "a1.pv");//dbvar1将指向数据库参数a1.pv VarRedir(dbvar1, "a2.pv");//dbvar1将指向数据库参数a2.pv dbvar1为已定义的数据库变量。 VarRedir(var, "var1"); var为间接变量，var1为要转向的变量名称。 sunwaywell

字符串指针和字符数组,静态全局、静态局部、全局和局部变量区别,字符串常量和字符串变量,程序的内存分配

最近工作之余，发现了两个自己在C语言学习中的难点，一个是字符串指针和字符数组的区别，一个就是静态全局变量、静态局部变量、全局变量和局部变量的区别，在网上查了不少资料，收获良多，现在与大家分享，有错误的地方请大家指正！ 以下程序用VC++6.0调试 先说说字符串指针和字符数组的区别 1.相同点： /* 用字符数组实现字符串操作*/ main( ) { char str[]="Welcome to study C !"; int i; printf("%s\n",str); for (i=0;i<=7;i++) printf("%c",str[i]); //用*(str+i)也行 printf("\n"); } /* 用字符指针实现字符串操作*/ main() { char *str="Welcome to study C !"; int i; printf("%s\n",str); for(i=0;i<=7;i++) printf("%c",*(str+i)); //用str[i]也行 printf("\n"); } 2.不同点： a)赋值方式不同，字符数组只能对各个元素分别赋值，而字符指针只需赋给字符串的 首地址就可以了。 如: char *str; str="Welcome to study C ！"; 以下对字符数组的赋值是错误的： char str[80]; str[ ]="Welcome to study C ！"; b)字符指针指向字符串，＂hello＂是一个字符串常量，与之相关联的内存空间位于内 存的只读部分，如: char ch[] = "china\n"; char *p; char *pp = "CHINA\n"; p = ch; *(p+2) = 'h';//就是可以的 *(pp+2) = 'h';//此处在编译时不会出错，在执行的时候会出错

C、C++字符串指针(指向字符串的指针)

C、C++字符串指针（指向字符串的指针） C语言中没有特定的字符串类型，我们通常是将字符串放在一个字符数组中，这里我们来演示一下： #include #include #include int main(){ char str[] = "hello world ！"; int len = strlen(str), i; //直接输出字符串 printf("%s\n", str); //每次输出一个字符 for(i=0; i #include #include

int main() { char str[] = "hello world !"; char *pstr = str; int len = strlen(str), i; //使用*(pstr+i) for (i = 0; i

字符串,字符数组,字符指针

字符数组，字符指针，字符串 char a[]="hello world"; char* b="hello world"; string c="hello wolrd"; cout<