C语言编程的问题：哪里出错了，指针搞得我好乱，题目要求还要用上SPRINTF函数~~乱了乱了，求高人指点

Question

#include <stdio.h>
#include <time.h>
void main()
{
char*horadatage(char*infoADater,char*infoDatee);
char*information="La chaine d`information";
char*informationDatee[40];
informationDatee=horadatage(information,informationDatee);
printf("L\'info datee est %s\n",&informationDatee);

}
char* horadatage(char*infoADater,char*infoDatee)
{
time_t t;
char buf[50];
t=time(NULL);
infoDatee=ctime(&t);
//printf("%s\n",infoDatee);
sprintf(buf,"%s:%s\n",infoDatee,infoADater);
return buf;
}
#include <stdio.h>
#include <time.h>
int main(void)
{
char*horadatage(char*infoADater,char*infoDatee);
char*information="La chaine d`information";
char informationDatee[40];
informationDatee=horadatage(information,informationDatee);
printf("L\'info datee est %s\n",&informationDatee);
return 0;
}

char* horadatage(char*infoADater,char*infoDatee)
{
time_t t;
char buf[50];
t=time(NULL);
infoDatee=ctime(&t);
//printf("%s\n",infoDatee);
sprintf(buf,"%s:%s\n",infoDatee,infoADater);
return;
}

主函数的部分不能改怎么办

Answer 1

下面是我收集的指针很好的文档，讲的很深入，楼主如果有兴趣，那么你可以看一下，如果不知道在哪里，你可以随时来问我。 。 。

第一章。的指针的概念

指针是一个特殊的变量，它的值存储在一个内存地址被解释为。

四个方面：类型，指针类型，指针所指向的，必须了解需要找出指针的指针，该指针的值，或者叫指针指向的内存区域，指针本身占据的内存区域。让我们分别说明。
站作为一个例子来声明几个指针：
示例：
（1）INT *;
（2）的char *指针;
（3）数组指针;
（4）INT（*）[3];
（5）诠释*（*）[4];

1。指针的类型。
语法的角度看，只要你删除的指针声明语句中的指针名，其余为指针类型。这是指针本身的类型。让我们来看看一个指针类型的例子：
（1）*指针/ /指针的类型诠释*
（2）的char *指针; / /指针的类型是char *
（3）*指针/ /类型的指针的数组
（4）INT（*）[3]; / /指针类型为int（*）[3]
（5）诠释*（*）[4]; /?? /指针的类型诠释*（*）[4]
怎么样？识别指针的类型的方法是不是很简单？

2。键入指针百分点。
当你通过指针来访问的指针所指向的内存区，指针所指向的类型的编译器，将修补的内存区域的内容看的东西。
在语法上，您需要到左边的是指针指向的指针的指针声明语句中的指针声明符*删除的类型的名称和名称。例如：
（1）*指针/ /指针指向int类型
（2）的char *指针; / /指针所指向的类型是char
（3）数组指针; / /指针指向的类型是int *
（4）INT（*）[3] / /指针指向int型（）[3]
（5）诠释*（*）[4]; /?? /指针所指向的类型诠释*（）[4]
指针运算，指针所指向的类型的显著作用。
的类型的指针类型（即，指针本身的类型）和指针指向两个概念。当你变得更加熟悉C，你会发现，“指针”类型混合在一起的概念转化为一种类型的“指针”和“指针所指向的类型”两个概念，重点精通指针之一。我读了很多书，发现一些不良写的书，把这两个概念指针搭配在一起，所以看看书不一致百思不得其解。

3。指针值，或所谓的区或地址的指针所指向的内存。
指针的值是指针本身所存储的值，并且该值作为地址，而不是一般的值将是编译器。 32个程序，所有类型的指针的值是一个32位的整数，因为所有的32个程序存储器地址是32位长。
指出由指针是从指针存储器地址，长度的sizeof（类型的指针所指向）的存储区域的值所表示的存储器区域。后来，我们说的指针的值是XX，相当于说的指针面积？存储器地址XX为首的，我们说一个指针块
内存区域是等效的指针的值是该存储区的第一地址。
的指针和该指针指向所指向的内存区域的类型是两个完全不同的概念。例如，指针所指向的类型了，但由于指针还未初始化，所以它所指向的内存区不存在，或者是毫无意义的。
每遇到一个指针后要问：是什么类型的指针？指针的类型是什么呢？在什么地方呢？
4。占用的存储器区域指针本身。
指针本身占了多大的内存？你只要用函数sizeof（指针类型）测试，以知道。在32位平台上，指针本身占据4个字节。
指针本身所占据的内存的概念是有用的，以确定是否一个指针表达式的左值。

第二章。指针的算术运算

指针可以是正或负的整数。此指针操作通常的数值减法的意义和重要性，是不一样的。例如：
例二：
1。的char [20];
2。诠释* =;
...
...
3。指针+ +;
在上面的例子中，int *类型的指针的指针，它指向的类型int，它被初始化为指向整型变量a。第三句的下一个指针，指针加1，编译器的方式来处理：值的指针的指针加的sizeof（int），在32位程序，再加上4。地址是字节，所以增加一个4字节的地址向高地址的指针变量的地址所指向的地址。
由于char类型的长度是一个字节，所以原来的指针四个字节起点的0号单元的阵列，这一次指向的数组a的从第4号单元开始的四个字节。
我们可以用一个指针和一个循环来遍历一个数组，看一个例子：
例三：
int数组[20];
诠释* =阵列;
...
/ /代码省略整数数组赋值。
...
（i = 0; <20; i + +）
{
（*）+ +;
指针+ +;
}
这种情况下，值的整数数组中的每个单元加1。每个周期的指针，指针加1，
给每个回路可访问的下一个单元的阵列。
看看这个例子：
示例：
1。的char [20];
2。诠释* =;
...
...
3。指针+ = 5;
在这个例子中，因此ptr +编译器这样的处理：指针指针加5倍的sizeof（int）的值，在一个32位的程序耦合用5×4 = 20。地址（以字节为单位）现在ptr指向的地址，以解决比指出，的指针加5至移动地址向高地址20个字节。在这个例子中，您没有添加前5 ptr指向数组中的第0号单元开始的四个字节，加5，ptr指向数组a的合法范围之外。虽然这种情况将问题中的应用，但是它的语法是可能的。这也反映了灵活性的指针。
上面的例子中，ptr是零下五，那么这个过程是大致相同的，不同的指针的值是零下5倍的sizeof（int），新的ptr指向解决比原来的指针指向的地址向低地址移动20个字节。

总结，一个指针ptrold与一个整数n，其结果是一个新的指针ptrnew，类型和ptrold ptrnew相同类型，指出的类型和ptrnew ptrold点的相同类型。 ptrnew的增加值比实际值的ptrold正一个sizeof（ptrold点式）的字节。也就是说，所指向的存储器区域的比sizeof（ptrold点的类型）的一个n字节的存储器区域移动到更高的地址ptrold点ptrnew。
后的指针ptrold减去一个整数n，导致一个新的指针ptrnew，ptrnew类型和ptrold所指向的类型和相同类型的ptrnew ptrold点的类型相同的。比减少ptrold的n值乘以者sizeof（ptrold点的类型）的字节，这就是说，为value ptrnew ptrnew比的存储器区域由ptrold移动指向朝向低地址所指向的内存区域的n sizeof（ptrold点式）的字节。

第三章。计算？放大器;

地址运算符，* ...书中被称为“间接的运算符。
及一个计算的结果是一个指针，指针类型是一个类型*指针指向的类型是一个类型，指针指向解决这个问题，那就是地址。
* P运算结果各不相同。短* P，P点的东西，这个东西有这些特点：它的类型是P点的类型，它占用的地址是由p指向的地址。
示例：
A = 12;
INT B;
* p;
数组指针;
P = &A; / /的结果，一个是指针类型是int *的点int类型的，地址指向的地址的。
* P = 24 ;/ / * p的结果，它的类型是int，它占用的地址是由p指向的地址，显然，* p是变量a。
PTR =即标准普尔/ /＆P的结果是一个指针，指针的类型是P *的类型，在这里诠释
*。指针所指向的类型的p型，诠释*。该指针指向的地址的地址指针p。
* PTR = &B; / / * ptr是一个指针，＆B的结果是一个指针，两个指针的类型和类型的点是一样的，所以和b来给* ptr指向的分配是没有问题的。
* PTR = 34 ;/ /结果是ptr ptr指向的东西，这里是一个指针，这是指
针再做一次*运算符，结果是一个int类型的变量。

第四章。指针表达式。

如果最后一个表达式的结果是一个指针，那么表达式被称为指针表达式。
下面是一些指针表达式的例子：
实施例6：
整数A，B;
int数组[10];
* PA;
PA = &A; / /＆a是一个指针表达式。
数组指针= &pa; / /＆pa是一个指针表达式。
* PTR = &B; / ~~ / *指针＆B是指针表达式。
PA =阵列;
PA + + ;/ /这是一个指针表达式。
实施例7：
字符*改编[20];
字符**帕尔改编;/ / ARR为指针，arr是一个指针表达式
字符*海峡;
STR = *帕尔帕尔;/ / *指针表达式
海峡= *（幼鱼+1）;/ / *（幼鱼+1）是一个指针表达式
海峡=（帕尔+2）;/ / *（帕尔+2）是一个指针表达式

作为结果的指针的表达是一个指针的指针具有四个要素：类型的指针，该指针指向指针本身的存储器指针表达式所占用的存储区的指针的类型。
那么，当一个指针表达式的结果是已经明确的指针的指针本身所具有的指针表达式所占用的内存是一个左值，否则就不是一个左值。
7＆A的案件是不是一个左值，因为它不占据了清晰的记忆。 * ptr是一个左值*指针的指针已经占用的内存，其实* ptr就是指针PA PA具有自己的内存，那么* ptr当然也有它自己的位置。

第一章。数组和指针之间的关系

如果该语句声明一个数组不太了解，前一段时间发布的文字我吗？ LT; <如何理解复杂的类型声明>> C和C + +。
数组的数组名其实也可以看作是一个指针。看下例：
实施例8：
int数组[10] = {0,1,2,3,4,5,6,7,8,9}，值;
...
...
值=数组[0] ;/ /也可以写为：价值= *阵列;
值=阵列[3] ;/ /也可以被写为：值= *（阵列3）;
值=阵列[4] ;/ /也可以被写为：值= *（阵列4）;
在上面的例子中，一般的数组名的数组代表数组本身，类型为int [10]，但如果
rray被看作是一个指针，它指向数组的0个单位，int *类型的点的数组类型是整数类型的单元。 *等于0的数组，这并不奇怪。同样，阵列3是一个指针到的前三个单元的数组的指针，所以*（阵列3）等于3。等等。
实施例9：
字符*海峡[3] = {
“你好，我是一个样！”
“嗨，早上好”。
“世界您好”
};
个char [80];
的strcpy（，str的[0]）;/ /也可写成像strcpy（*海峡）;
的strcpy（，str的[1]）;/ /也可写成像strcpy（*（海峡+1））;
的strcpy（，str的[2]）;/ /也可写成像strcpy（*（海峡+2））;
另外，在上述的例子中，str是一个三单元阵列，阵列的每个元素是一个指针，这些指针分别指向一个字符串。的数组名str的指针的指针，它指向数组第0号单元，它的类型是char **，它指向的类型是char *。
* str是一个指针，它的类型是char *，它指向的类型是char，它指向的地址的字符串“您好，这是一个简单的，”第一个字符的地址，'H'的地址。
STR +1是一个指针，它指向数组的1号单元，它的类型是char **，它指向的类型是char *。
*（STR +1）是一个指针，它的类型是char *，它指向的类型是char，它指向“嗨，早上好。”的第一个字符“H”，依此类推。

下面总??结的名称的数组的数组。声明一个数组类型的数组的数组名数组[N]，有两方面的含义：第一，它代表整个数组，它的类型是TYPE [N];其次，它是一个指针的指针类型TYPE *指针类型类型，这是一个数组单元的类型，指针指向的内存区域的单位是一个阵列0号，这个指针占用一个单独的内存区，注意，数组的0个单位占用内存区域是不同的。指针的值不被，这是类似于数组+ +表达式是错误的。
数组名数组可以扮演不同的角色，在不同的表达式。
表达式sizeof（数组），数组名数组代表数组本身，所以这个时候sizeof函数
测量得到的整个阵列的大小。
表达式*数组，数组中起着指针，所以此表达式的结果是数组的第0号单元的值。测量的大小（*数组）的数组元素的大小。
表达阵列+ N（其中n = 0,1,2，...），阵列发挥是一个指针，所以改编
AY + n的结果是一个指针类型TYPE *，它指向的类型TYPE，它指向数组的第n个单元。因此中，sizeof（数组+ n）的测量的指针类型的大小。
实施例10：
int数组[10];
（*）[10];
PTR = &array;
例如ptr是一个指针，它的类型是int（*）[10]，他指出，输入数据类型为int [10]
我们用整个数组的首地址来初始化它。声明指针和数组，该数组代表数组本身。

本节中，sizeof（）函数，然后我来问sizeof（指针名字）的实测研究
实际上的指针所指向的类型的指针类型或尺寸的大小？答案是前者。例如：

（*）[10];
在32位程序，主要有：
如sizeof（int（*）[10]）== 4
SIZEOF（[10]）== 40
sizeof（指针）的== 4
事实上，sizeof（对象）的测量对象类型的大小，而不是任何类型的大小。

第六章。指针和结构的关系的类型

你可以声明一个指向结构类型对象的指针。
实施例11：
结构mystruct
{
诠释一;
INT B;
诠释三;
}
MyStruct SS = {20,30,40} ;/ /声明结构体SS，和ss的三个成员的初始
成20，30和40。
MyStruct * = &ss; / /声明一个指针，指向一个指针，指向一个结构体SS。它的类型是
MyStruct *，它指向的类型MyStruct。
* PSTR（*）&ss; / /声明一个指针，指向一个指针，指向一个结构体SS。但是，
类型和PTR类型和它是不同的。

如何可以通过一个指针PTR SS三个成员变量？
答：
PTR-> A;
PTR-> B;
PTR-> C;
请问如何访问SS三个成员变量的指针PSTR？
答：
* PSTR ;/ /获取的党卫队成员。
*（PSTR 1）;/ / b的党卫队成员。
*（PSTR 2）/ /访问C SS的成员。
虽然我在我的MSVC + +6.0上调代码，但要知道，这样使用p
str的访问结构的成员是非正式的，为了解释为什么非正式的，让我们来看看如何通过指
针访问的各种元素的数组：
实施例12：
int数组[3] = {35,56,37};
* PA =阵列;
访问数组的数组的指针PA三个单位的方法：
* PA ;/ /浏览0件
*（PA +1）;/ /获取第1个单位
*（PA +2）;/ /获取的2号机组
从格式上来看，倒是格式的形式化方法，通过指针访问结构成员。
所有的C / C + +编译器总是安排阵列单元，每个数组元素存储在连续的存储区域，单位和单位之间没有空隙。然而，在存储的各个成员对象的结构，在一个特定的编译器环境中，可能需要字对齐或双字对齐，对齐两个相邻的成员之间加上一定的吗？ “填充字节此引线可能之间的间隙的各个成员的字节的数目
因此，在12例PSTR的一个成员变量的对象SS A的结构，不能保证*（PSTR 1）将能够访问结构的成员。因为可能有一些成员之间的成员的b可能*（PSTR 1），只是访问这些填充字节的填充字节。这也证明了指针的灵活性。如果你的目的是想看看在成员之间的各种结构到底有没有填充字节
嘿，这的确是一个好办法。
指针来访问正确的结构应该是这样的方法使用指针的指针例1??2。

第七章。指针和功能之间的关系的

你可以声明一个指针，一个指向函数的指针。
诠释FUN1（char *，则INT）;
（* pfun1）（char *，则INT）;
pfun1 = FUN1;
....
....
=（* pfun1）（“ABCDEFG”，7）;/ /通过函数指针调用函数。
作为一个参数的函数的指针。函数调用语句，您可以使用指针表达式
参数。
实例13：
有趣的（char *）的;
诠释一;
字符海峡[] =“ABCDEFGHIJKLMN”;的
=乐趣（STR）;
...
...
有趣的（字符*）
{
NUM = 0;
为（int i = 0;
{
NUM + = * S，S + +;
}
返回num;
）
在这种情况下，函数fun统计一个字符串中的单个字符的ASCII值。正如所述，该数组的名称是一个指针。函数调用时，str作为一个参数传递给正式的参数s，str的实际价值传递给S，S点到相同的地址，指向的地址，将str，str和s各自占用各自的存储空间。在函数体内的自我加1操作，并不意味着运营商的自我强加给乙方。

第八章。指针的类型转换

当我们初始化一个指针，指向一个指针赋值，赋值是一个指针向左，右侧的一个指针表达式中的分配。在我们以前的例子，在绝大多数情况下，指针和指针类型的表达式的类型是一样的，指针所指向的类型和指针表达式的类型是一样的。
例十四：
1。浮动f = 12.3;
2。浮* fptr，实施的代码如下= &f;
3。 * p;
在上面的例子中，如果我们想让指针p指向的实数f，怎么搞的？用下面的语句吗？
P = &f;
这是错误的。由于类型的指针p是对int *，它指向的类型是int。表达式＆f的结果是一个
一个指针，指针的类型是float *，它指向float类型。两者之间的差别，直接分配。至少在我的MSVC + +6.0指针赋值语句要求的类型，赋值号两侧的线，点，线的类型，我还没有尝试过其他的编译器，大家可以试试。为了实现我们的目标，“中投”：
P =（*）&f;如果有一个指针p，我们需要的类型，其类型，并指出，而不是TYEP * TYPE
语法格式是：
（TYPE *）P;
这样的结果蒙上了新的指针，指针类型TYPE *，它指向的类型TYPE，它指向的地址是原来的指针的地址。原始指针p的所有属性都没有被。

如果您使用一个函数指针作为参数，然后指针类型的转换也发生在结合过程中的参数和参数的函数调用语句。
例五：
无效的乐趣（char *）的;
A = 125，B;
有趣的（（CHAR *）＆A）;
...
...
无效乐趣（字符* S）
{
字符c;
C = *（3）*（+3）= *（+0）*（+0）= C;
= *（2）*（2）= *（1）*（1）= C;
}
}
请注意，这是一个32位程序，故int类型占四个字节的char类型占一个字节。的功能的乐趣的作用是一个反相的整数的四个字节的顺序。注意到了吗？函数调用语句的参数，结果和a是一个指针，它的类型是int *，它指向的类型是int。参数指针的类型是char *，它指向的类型是char。实时参和形参的结合过程中，一定要进行一次从int *类型转换为char *类型。结合这个例子，我们可以想像，编译器将其转换的过程：编译器先构造一个临时指针的char *温度，然后做TEMP =（CHAR *），最后的温度值传递到S。因此，最后的结果是：s类型是char *，它指向的类型是char，它指向的地址的第一个地址是一个。

我们已经知道，在32位程序的值是一个指向指针的地址的指针的值其实是一个32位的整数。整数指针的指针的值直接吗？下面的语句：
unsigned int类型;
TYPE * ;/ / TYPE类型为int，char或结构类型，等等。
...
...
A = 20345686;
PTR = 20345686 ;/ /我们的目标是使指针ptr指向地址20345686（十进制
）
PTR = ;/ /我们的目标是使指针ptr指向地址20345686（十进制）
编译它。结果表明，后者的两个语句都是错误的。不能达到我们的目的？不，有办法：
unsigned int类型;
TYPE * ;/ / TYPE类型为int，char或结构类型，等等。
...
...
=一个数字，这个数字必须代表一个合法的地址;
PTR =（TYPE *）;/ /这个可以。
严格来说，是不一样的（TYPE *）指针类型转换（类型*）。 （TYPE *）的意思是无符号整数的值作为地址以寻找。
上文所强调的，必须代表一个合法的地址，或当您使用指针的值，会有一个非法操作错误。

想到的就可以了，反过来，以指针的地址的指针值作为整数。完全。下面的例子演示了作为一个整数的指针的值，那么这个整数作为地址分配给一个指针：
例十六：
A = 123，B;
诠释* = &A;
字符*海峡;
B =（int）的指针;/ /指针的指针的值作为整数。
海峡=（CHAR *）B ;/ /这个整数的值作为地址指针海峡。

好了，我们已经知道，值的指针作为一个整数取出来，也可以被分配到一个指针，指向的地址的整数值。

第九章。指针的安全问题

请看下面的例子：
实施例17：
个char ='A';
诠释*;
PTR =（*）＆S
* PTR = 1298;
指针ptr是一个int *类型的指针，它指向的类型是int。它指向的地址的地址。 S共享一个32位的程序中的一个字节，int类型占4个字节。的最后一条语句不但改变字节的份额也高地址方向和S相邻的三个字节改变。三个字节都在干什么？只有编译器知道，而写程序，就不大可能知道。一个很重要的数据可以存储在三个字节，可能是三个字节只是程序代码指针的马虎应用的三个字节的值被改变！这将导致错误的崩溃。
让我们看一个案例：
实施例18：
1。字符;
2。诠释* = &A;
...
...
3。指针+ +;
4。 * PTR = 115;
这个例子完全可以通过编译，并可以执行。但是看到的不是吗？ 3句，因为加1操作，ptr指向的存储区域相邻的地址和整型变量的指针的指针的方向。这家商店是什么呢？我们不知道。可能是它是一个非常重要的数据，甚至可能是一个代码。甚至数据写入到这家店！这是一个严重的错误。指针，程序员心里必须非常清楚：我的指针指向哪里。
访问数组指针，我们必须小心，不要超出边界的数组的低端和高端否则会造成类似的错误。
指针类型的强制转换：PTR1 =（TYPE *）PTR2，的大小（PTR2为类型）
SIZEOF（ptr1的类型），那么它是安全的，，在使用指针PTR1，访问指向的存储区时的PTR2。如果小于sizeof（ptr1和类型）的大小（PTR2类型）时，在使用指针PTR1，访问指向的存储区，PTR2是不安全的。至于为什么，读者结合例17去想它，它应该被理解。

Answer 2

（1）main函数中的 char*informationDatee[40]表示的是字符串指针数组，根据上下文，你应该改成char*informationDatee。
（2）horadatage函数中的变量buf不应该被返回，因为它是局部变量，return后内存被释放，这样在main中它就不能被访问了你应该把它声明为：int horadatage(char*infoADater,char*infoDatee， char *buf); 返回0表示函数执行成功，-1表示失败。buf参数用以保存函数执行结果。本回答被提问者和网友采纳

Answer 3

根据代码的意思是想给一个输入语句加上UTC时标是吧？
那 改成这样
void main()
{
void horadatage(char*infoADater,char*infoDatee);
char*information="La chaine d`information";
char informationDatee[40] = “”;

horadatage(information,informationDatee);

printf("L\'info datee est %s\n", informationDatee);
}
void horadatage(char*infoADater,char*infoDatee)
{
time_t t;

t=time(NULL);
infoDatee=ctime(&t);
//printf("%s\n",infoDatee);
sprintf(&infoDatee[strlen(infoDatee)], ":%s\n", infoADater);

return ;
}

这样就行

Answer 4

lxm2322回答得很好了，另外 sprintf函数的作用仅是把字符串格式化好以后放入一个缓冲区，没啥恐惧不懂的

Answer 5

弄得整齐一些，你这样弄这么乱谁看的清楚