初步来看，进展还是不错的，最好的进展是有了自信心。
所以这样的教程是适合有一定C基础的人学习C++的，菜鸟和新手50（称之为入门阶段）刷完之后，就可以下一步计划，青铜计划 <<
感谢大佬几款优秀的支持C、C++在线编译器
stage1——4天入门阶段
教程网站：C++ 教程
在线编译器：compile c++ gcc online
刷题网站：阶段1第一关：基本数据类型
day3 planA
教程(19-23)+7，刷题2+3(5)，复习1
教程完成度8.3%，刷题完成度9.1%，复习完成度100%
主要原因：可恶，指针内容太多了。另，总也不是想做什么就没有旁的事找来的。虽然得承认，旁的事真好玩，四舍五入是最后的尊严 <<
1.指针
每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号&运算符访问的地址，它表示了在内存中的一个地址。
可用于输出变量，数组（数字和字符），字符串的地址（或首元素地址）
#include <iostream>
#include <string>
using namespace std;
int main()
{
int a=5;
char try1[13]="hiya";
string s="do";
cout << &a << endl;
cout << &try1 << endl;
cout << &s << endl;
}
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
指针变量声明的一般形式为：
type *var-name;
type是指针的基类型，它必须是一个有效的C++数据类型，var-name是指针变量的名称。用来声明指针的星号*与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。
>>> !!! 注意 >>>
> 所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。
> 不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。
使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符*来返回位于操作数所指定地址的变量的值。
1.1 NULL指针
在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个NULL值是一个良好的编程习惯。赋为NULL值的指针被称为空指针。
NULL指针是一个定义在标准库中的值为零的常量。
不初始化，或者定义为NULL，指针的值都为0
#include <iostream>
using namespace std;
int main()
{
int *p=NULL;
int *t;
cout << p << endl;
cout << t << endl;
return 0;
}
在大多数的操作系统上，程序不允许访问地址为0的内存，因为该内存是操作系统保留的。
然而，内存地址0有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
因此，如果所有未使用的指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。
#include <iostream>
using namespace std;
int main()
{
int *p=NULL;
int a=1;
int *t;
t=&a;
//cout << t << endl;
if(t) cout << t << endl;
else cout << p << endl;
return 0;
}
1.2 指针的算术运算
指针是一个用数值表示的地址。可以对指针进行四种算术运算：++、--、+、-。
//测试实例
//int型指针，自加1，则字节向后移动4个字节
#include <iostream>
using namespace std;
int main()
{
int a=1;
int *t;
t=&a;
cout << t << endl;
t++;
cout << t << endl;
return 0;
}
输出-------------------------------------------
0x7fff30195ab4
0x7fff30195ab8
我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，因为数组是一个常量指针。
#include <iostream>
#include <iomanip>
using namespace std;
const int N=3;
int main()
{
int gr[N]={1,2,3};
int *p;
p=gr;
for(int i=0;i<N;i++)
{
cout << setw(10) << "number" << setw(10) << gr[i] << setw(10) << "address" << setw(20) << p << endl;
p++;
}
return 0;
}
同样地，对指针进行递减运算，即把值减去其数据类型的字节数。
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int var[MAX] = {10, 100, 200};
int *ptr;
// 指针中最后一个元素的地址
ptr = &var[MAX-1];//因为var是var[0]的地址，所以最后一个元素地址为var[MAX-1]
for (int i = MAX; i > 0; i--)
{
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// 移动到下一个位置
ptr--;
}
return 0;
}
>>> 这里需要明确，数组名称 var 可表示数组地址，即 var[0] 的地址，赋给指针时直接使用 p=var 即可，也等于 p=&var[0] ；
> 但若是需要将数组其他元素的地址赋给指针，则需要借助 & 符号，如 p=&var[1] ，这是和将变量的地址取出进行赋值是一样的。
指针进行比较时，指针可以用关系运算符进行比较，如==、<和>。
//搬运工，感谢菜鸟
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int var[MAX] = {10, 100, 200};
int *ptr;
// 指针中第一个元素的地址
ptr = var;
int i = 0;
while ( ptr <= &var[MAX - 1] )
{
cout << "Address of var[" << i << "] = ";
cout << ptr << endl;
cout << "Value of var[" << i << "] = ";
cout << *ptr << endl;
// 指向上一个位置
ptr++;
i++;
}
return 0;
}
1.3 指针与数组
如前面所说的，一个指向数组开头的指针，可以通过使用指针的算术运算或数组索引来访问数组。
然而，指针和数组并不是完全互换的。
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int var[MAX] = {10, 100, 200};
for (int i = 0; i < MAX; i++)
{
*var = i; // 这是正确的语法
cout << *var << endl;
cout << var << endl;
//var++; // 这是不正确的
}
return 0;
}
注意 ！！！
>>> !!! 注意 >>>
> 数组的名称表示数组的地址，即第1个元素（[0]）的地址；
> 可以将数组名称直接输出，或者赋值给指针，都是将数组的地址或首个元素地址进行输出或赋值；
> 如果对 *var 赋值，是可以的，是将值赋到数组首个元素；
> 但不能直接对数组名称 ++ ，只能赋值给指针后 ++ 。
由于一个数组名对应一个指针常量，只要不改变数组的值，仍然可以用指针形式的表达式。例如，
*(var + 2) = 500;
1.4 指针数组
指向 int 或 char 或其他数据类型的指针数组，比如
int *p[3];
需要注意的是，指针数组有3种使用方式，1是用于数字数组，2是用于字符数组，3是用于字符串数组。
- 数字数组
指针数组的每个元素，都是指向对应类型（比如上述的指向int类型）值的指针。
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int var[MAX] = {10, 100, 200};
int *p[MAX];
for (int i = 0; i < MAX; i++)
{
p[i] = &var[i];
cout << p[i] << endl;
cout << *p[i] << endl;
}
return 0;
}
输出-----------------------------------------
0x7fff0be1065c
10
0x7fff0be10660
100
0x7fff0be10664
200
- 字符数组
#include <iostream>
using namespace std;
int main ()
{
char tt[]="hola";
char *p[4];
p[0]=&tt[0];
cout << p[0] << endl;
cout << *p[0] << endl;
p[1]=&tt[1];
cout << p[1] << endl;
cout << *p[1] << endl;
return 0;
}
输出-----------------------------------------------
hola
h
ola
o
- 字符串数组
可以用一个指向字符的指针数组来存储一个字符串列表，即字符串数组。本质是存储指针的数组，既存储 char 类型的指针的数组, 数组内的每个元素都是一个指针指向一个存储 char 类型的地址。
#include <iostream>
using namespace std;
const int MAX = 4;
int main ()
{
const char *names[MAX] = {
"Zara Ali",
"Hina Ali",
"Nuha Ali",
"Sara Ali",
};
for (int i = 0; i < MAX; i++)
{
cout << "Value of names[" << i << "] = ";
cout << names[i] << endl;
}
return 0;
}
输出---------------------------------------
Value of names[0] = Zara Ali
Value of names[1] = Hina Ali
Value of names[2] = Nuha Ali
Value of names[3] = Sara Ali
- 归纳整理
现在来回顾整理一下3个概念：
>>>
> 1. 数字数组
> //一维
> int num[5];
> int num[]={1,2,3};
> int num[3]={1,2,3};
> //二维
> int numm[2][3];
> int numm[2][3]={1,2,3,4,5,6};
> int numm[2][3]={{1,2,3},{4,5,6}};
>
> //指针数组
> int num[3]={1,2,3};
> int *ptr[3];
>
> !!! 赋值要用取地址符&，独立元素赋地址
> ptr[0]=&num[0];
> !!! ptr[0]保存的是num[0]的地址
> !!! *ptr[0]保存的是num[0]中的元素，即数字
>
> 2. 字符数组
> char str[5];
> char str[]="hello";
> char str[6]={'h','e','l','l','o','\0'};
> char str[10]="hello";//为了防止缓存错误，留出一个\0的位置
> 可以像数字数组一样通过索引改变元素，eg
> str[1]='o';//要用单引号表示字符
>
> //指针数组
> char str[]="hello";
> char *ptr[5];
>
> !!! 赋值也要用取地址符&，但是更像是将从某位起到\0终止的字符串进行赋值，和字符串数组相同
> ptr[0]=&str[0];
> !!! ptr[0]中保存的是str[0]起到\0终止的字符串，如hello
> !!! *ptr[0]中保存的是str[0]起到\0终止的字符串首地址的值，如h
>
> 3. 字符串数组
> char *ptr[3]={"hi","hello","hola"};
>
> !!! 每个字符串数组元素保存一个字符串，如ptr[0]保存hi
> !!! *ptr[0]保存字符串首地址的值，如h
> !!! *(ptr[0]+1)保存字符串第2个地址的值，如i
> 所以可以这么理解，字符串数组的每个元素（不加*）其实还是指向字符串的地址，但直接输出为该地址起的字符串；
> 而字符串数组的元素加*，则为该元素中地址对应的字符串的第1个字符
//加深印象的例子
#include <iostream>
using namespace std;
void pointerArray();
void pointerArray4Char();
const int MAX = 3;
int main(void){
// pointerArray();
pointerArray4Char();
return 0;
}
void pointerArray(){
int var[MAX] = {20,30,40};
int *ptr[MAX];
for(int i = 0; i < MAX; i++){
ptr[i] = &var[i];//赋值为整数的地址
}
for(int i = 0; i < MAX; i++){
cout << "Value of var[" << i << "] = ";
cout << *ptr[i] <<endl;
}
}
/**
* 用一个指向字符的指针数组来存储一个字符串列表
* Value of names[0] = sun;
*/
void pointerArray4Char(){
const char *names[MAX] = {
"sun","bin","sunbin"
};
for(int i = 0;i < MAX;i++){
cout <<"Value of names[" << i << "] = ";//输出字符串的值
cout << names[i] << endl;
cout <<"Value of *names[" << i << "] = ";//输出指针所指向字符串首地址的值
cout << *names[i] << endl;
cout <<"Value of *names[" << i << "]+1 = ";//输出ascii码值
cout << *names[i]+1 << endl;
cout <<"Value of *(names[" << i << "]+1) = ";//输出指针所指向字符串首地址上一位的值
cout << *(names[i]+1) << endl;
}
}
C++ 运算符的优先级中，* 小于 []
1.5 指向指针的指针
指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。
指针的指针就是将指针的地址存放在另一个指针里面。
通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号**。
int **p;
当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符。
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
int var;
int *ptr;
int **pptr;
var=1;
ptr=&var;
pptr=&ptr;
cout << "origin number " << " number's address " << " address's address" << endl;
cout << setw(13) << var << setw(18) << ptr << setw(19) << pptr << endl;
cout << setw(13) << *ptr << setw(18) << *pptr << endl;
cout << setw(13) << **pptr << endl;
return 0;
}
输出-------------------------------------
origin number number's address address's address
1 0x7ffdefb2d7ac 0x7ffdefb2d7b0
1 0x7ffdefb2d7ac
1
1.6 传递指针给函数
记得在前面，函数部分提到过。
一般来说，函数有几种调用参数的方式：
1. 传值调用。 形参和实参都是变量；
2. 指针调用。 形参指针，实参地址；eg.void opp(int *a);int b;opp(&b);
3. 引用调用。 形参用引用符&，实参变量；eg.void opp(int &a);int b;opp(b);
//搬运例子
#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;
}
使用指针调用的时候，如果是数组，实参就是数组的名称（实际名称就代表数组首地址）
>>> !!! 注意 >>>
> 使用指针调用的时候，如果是数组，实参就是数组的名称（实际名称就代表数组首地址）
#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;
}
复习一下：
#include <iostream>
using namespace std;
double ava(int *gr,int sizee)
{
int sum=0;
for(int i=0;i<sizee;i++)
{
sum+=gr[i];
}
return (double)sum/sizee;
}
int main(void)
{
int balance[5] = {1000, 2, 3, 17, 50};
cout << sizeof(balance)/sizeof(balance[0])<< endl;
int sizeb = sizeof(balance)/sizeof(balance[0]);
double avarage=ava(balance,sizeb);
cout << avarage << endl;
return 0;
}
注意！！！
>>>!!! 注意>>>
> sizeof(a);
> 如果a是一个数组，就返回数组中所有元素的总字节数
> 所以，若想得到数组中的元素个数，就要用'总字节数/变量类型字节数'
> eg. int balance[5] = {1000, 2, 3, 17, 50};
int sizeb = sizeof(balance)/sizeof(balance[0]);
1.7 从函数返回指针
声明一个返回指针的函数：
int * myFunction()
{
.
.
.
}
C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为static变量。
#include <iostream>
#include <cstdlib>
using namespace std;
int * getrand()
{
srand(500);
static int r[10];
cout << "随机生成数：" << endl;
for(int i=0;i<10;i++)
{
r[i]=rand();
cout << r[i] << endl;
}
return r;
}
int main()
{
int *p;
p=getrand();
cout << "--------------" << endl;
for(int i=0;i<10;i++)
{
cout << *(p+i) << endl;
}
return 0;
}
注意！！！
>>>!!! 注意>>>
> 如果函数返回值是一个指针，且是指向数组的指针，那么函数格式为 int * ab(){}
> 在函数定义的时候，要定义一个数组，!!!必须加上static，然后对该数组操作，返回值直接用数组名称，即代表数组元素首地址，int * ab(){static int r[3];... return r;}
> 在调用的时候，只需要一个指针即可，但该指针指向的是数组元素首地址，int *p;p=ab();
832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
