函数指针数组初始化（用C语言在主函数中定义和初始化一个二维数组a[3][4]和一个指针数组，采用指针数组去访问数组元素a[2][4]）

本文目录

• 用C语言在主函数中定义和初始化一个二维数组a[3][4]和一个指针数组，采用指针数组去访问数组元素a[2][4]
• 怎么初始化指针数组
• 在main函数中定义基类的指针数组，分别用来指向不同的四个派生类，并初始化个派生类
• 结构体指针数组怎么初始化
• C指针数组的初始化
• C++编写函数几个,创建函数指针数组,将几个函数的内存保存,然后调用函数
• C语言 malloc函数怎么用的..就是动态初始化字符指针数组.
• c++编写动态数组类 TArray,构造函数里指针数组初始化问题
• keil C 编程初始化指针函数数组时出错
• 指针数组问题“定义并初始化一个指针数组“

用C语言在主函数中定义和初始化一个二维数组a[3][4]和一个指针数组，采用指针数组去访问数组元素a[2][4]

#include "stdio.h"
void main()
{
int a={0,1,2,3,4,5,6,7,8,9,10,11};
int (*b);
b=a;
printf("%d",*(*(b+1)+3));
}

怎么初始化指针数组

#include《stdio.h》 //报错可能1. 要引入头文件。
int main() //报错可能2. 没有在main函数前写返回类型int
{
//代码省略
return 0; //报错可能3. 没写return 0.
}
你将这些都加上应该就不会报错了。

在main函数中定义基类的指针数组，分别用来指向不同的四个派生类，并初始化个派生类

要知道,子类对象包含其基类对象,子类指针强制为基类指针时,指向的对象,就是基类对象,反过来.基类指针强制为其子类指针时,它就可以调用其子类对象的构造函数.具体是
shape *shpe;
(A*)shpe=new A;
这样,一个其派生类对象就产生了.
当然这如果直接用,shpe来使用这个对象不行的,毕竟这是基类指针,每次使用都得强制转换为子类指针.

结构体指针数组怎么初始化

(1)
int a={1,2,3,4,5}; //OK
(2)
int a;
a={1,2,3,4,5};
//ERROR
结论:对于数组用大括号{}的赋值方式只是在定义的时候适用
否则必须用循环的方式
结构体初始化(方法一)
using
namespace std;
struct S{
int i;
float f;
};
struct S
s={10,15.5};//使用{}的正确方式
如果改成
struct S
s;
s={10,15.5};就不行
方法二(通行的方法)
从Ucos_ii.c内核代码中学到的
OS_MemClr((INT8U
*)&OSTCBTbl,sizeof(OSTCBTbl));Clear all the
tcb
下面是给结构体数组清零的函数,实质是将结构体占据的内存区域视为字符变量区域
,用循环对单个内存字节单元的清零来实现对结构体占据的内存区域即(结构体)的清零
void
OS_MemClr (INT8U *pdest, INT16U size)
{
while (size 》 0) {
*pdest++
= (INT8U)0;
size--;
}
}
注意函数OS_MemClr中的强制类型转换 INT8U
(*)&OSTCBTbl,
目的是将结构体指针转化成字符型指针,对单个内存单元的清零(*pdest++ =
(INT8U)0;),来完成对结构体的清零(或者是结构体数组)

C指针数组的初始化

你声明的是一个float类型的指针数组ranges
也就是说数组的每个元素都是指向float 类型变量的指针，你直接用数值360去赋初值，肯定是错的，0是正确的，因为它把0当成了空指针NULL来处理。
正确的赋值方法，只有声明几个float类型的指针变量，再用这些指针变量给指针数组 ranges 赋初值。
比如：
float a,b,c;
float *ranges={&a,&b,&c};

C++编写函数几个,创建函数指针数组,将几个函数的内存保存,然后调用函数

函数指针数组
定义并初始化：int (* p)(int *) = {0};
它是一个包含10个返回值是int, 参数是整型指针的函数指针的数组， 数组名为p。
或者
typedef int (*PF)(int *);
PF p = {0};

C语言 malloc函数怎么用的..就是动态初始化字符指针数组.

如果是字符指针数组，则就是二级指针了，如果分配n * m数组，则：
int i, n = 10; m = 20;
char **p = (char**)malloc(n * sizeof(char*));
for(i = 0; i 《 n; ++i)
p = (char*)malloc(m * sizeof(char));

c++编写动态数组类 TArray,构造函数里指针数组初始化问题

main.cpp
#include "1.h"
int main()
{
TArray a(10); // a是一个double 类型的长度为10动态数组
TArray b; // b是一个double 类型的尚未确定其长度的动态数组
b.SetLen(7); // 使b成为一个长度为7的动态数组
double d = { 1,2,3,4,5,6,7,8,9,10 };
a.Input(d,10); // 把c中的10个元素复制到a中
a.Print(); // 打印a中的元素
TArray c(a); // 创建了一个与a一样的c数组
b = a; // 把a的内容复制给b
a.SetElem(0,6); // 把第0个元素的值重新赋值为6
b.Exchange(4,2); // 交换b中第4个和第2个元素的内容
b.Print(); // 打印b中的元素
a.Print(); // 打印a中的元素
c.Print(); // 打印c中的元素
return 0;
}
1.h
#include《iostream》
using namespace std;
class TArray
{
private:
double *a;
int n;
public:
TArray();
TArray(int number);
TArray(TArray &p);
void SetLen(int m);
void Input(double *b,int m);
void Print();
void SetElem(int m,double r);
void Exchange(int m,int r);
TArray operator=(TArray);
~TArray();
};
TArray::TArray()
{
a=NULL;//默认构造a=NULL,n=0;你的那个n没初始化，a申请内存肯定出错
n=0;
}
TArray::TArray(TArray &p)
{
n=p.n;
a=new double;
for(int i=0;i《n;i++)
a;
}
TArray::TArray(int number)
{
n=number;
a=new double;//得申请内存
}
void TArray::SetLen(int m)
{
n=m;
a=NULL;//得声明a=NULL
}
void TArray::Input(double *b,int m)
{
n=m;
for(int i=0;i《m;i++)
{
a;
}
}
void TArray::Print()
{
for(int i=0;i《n;i++)
{
cout《《a《《" ";
}
cout《《endl;//加个endl让输出界面明朗
}
void TArray::SetElem(int m,double r)
{
a=r;
}
void TArray::Exchange(int m,int r)
{
double temp;
temp=a;
a;
a=temp;
}
TArray TArray::operator=(TArray c)
{
a=new double;//给你改了一下这个函数，你那个有问题
for(int  i=0;i《n;i++)
a;
return *this;
}
TArray::~TArray()
{
delete a;
}

满意请采纳哦！

keil C 编程初始化指针函数数组时出错

研究了一下这个问题。Keil报non-address/-constant initializer是正确的，因为advanceModeFun和advModeSetting是在同一级别初始化的，此时后者不可能知道前者的真实地址。

所以你的这个问题，暂时来看有两种解决方法：

其一，就是像你所说的，用地址确定的函数声明（例如advMode1SetAdj）来赋给advModeSetting的元素。当然这种方法你是不喜欢的。

其二，就是在运行时将advanceModeFun的元素赋给advModeSetting，达到你的需求。例如：

void (* advModeSetting)(void) = {
 //advanceModeFun.KeySetting,
 advMode1SetAdj,
 advMode2SetAdj,
};
 
void main()
{
 advModeSetting();
 advanceModeFun.Display();
 advModeSetting.KeySetting;
 advModeSetting();
 while(1);
}

这段例程中，第一个advModeSetting()实际调用advMode2SetAdj()。

指针数组问题“定义并初始化一个指针数组“

刚刚回答的一个问题：
要求编一自定义的函数sort()，完成对n个字符串的降序排序，然后在main()函数中调用sort()对"Beijing","Shanghai","Shenzhen","Nanjing","Dalian","Qingdao"这6个字符串排序，要求用指针数组表示这6个字符串。你的是按照从小到大，我这是从大到小，道理是一样的。
以下是程序：
//VC++ 6.0编译通过。保存为.c文件就可以编译
//TurboC 我没试过，如果你要用Turbo C编译，请你将里面的注释都删除
//因为在TC中只认识带星号的多行注释。
//此程序虽然是用VC++ 6.0编译，但是是纯C语言的语法。没有包含任何
//C++的内容
#include《string.h》
//进行排序的函数，主要是对字符串数组进行排序
//size表示数组元素个数
//此排序算法使用的是选择排序
//利用到了C语言中的字符串比较函数strcmp(str1,str2)
//此函数的两个参数都是char*类型。
void sort(char *str,int size)
{
int i,j;
for(i=0;i《size-1;i++)
{
for(j=i+1;j《size;j++)
if(strcmp(str)《0)
{
char *p=str;
str;
str=p;
}
}
}
//打印一个字符串数组的内容
//size表示字符串数组元素的个数
void print(char *str,int size)
{
int i;
for(i=0;i《size;i++)
{
printf(str);
printf(",");
}
printf("\n");
}
void main()
{
char *str={"Beijing","Shanghai","Shenzhen","Nanjing","Dalian","Qingdao"};
printf("排序之前的结果:\n");
print(str,6);
sort(str,6);
printf("排序之后的结果:\n");
print(str,6);
}