C语言深度学习—

首先声明一下，在我们写的程序中，会使用到一个头文件# include <head.h>

因为，在linux系统编程的时候，会用到很多头文件，为此，我用一个头文件全部包含在一起，头文件内容如下：

# ifndef _OK_

# define _OK_

# include <stdio.h>

# include <string.h>

# include <errno.h>

# include <stdlib.h>

# include <time.h>

# include <unistd.h>

# include <sys/types.h>

# include <sys/stat.h>

# include <fcntl.h>

# include <sys/types.h>

# include <dirent.h>

# include <pwd.h>

# include <grp.h>

# include <pthread.h>

# include <semaphore.h>

# include <signal.h>

# include <linux/ipc.h>

# include <sys/socket.h>

# include <netinet/in.h>

# include <arpa/inet.h>

# include <sys/wait.h>

# include <netdb.h>

#define LOG(...) {char _bf[1024];snprintf(_bf,sizeof(_bf),__VA_ARGS__);\

       fprintf(stderr,"%s",_bf);syslog(LOG_ERR,"%s",_bf);}

#endif

编辑好了之后，放到/usr/include/下即可。

1. 使用__FILE__,__FUCTION__,__LINE__等宏能自动定位到程序执行到哪一个函数的哪一行，作为一个经典的调试方法，很容易被人忽略，也很重要。如下：

#include <stdio.h>

void test()

{

    printf("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);

}

void test_1()

{

    printf("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);

    test();

}

int main()

{

printf("1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", +  +  +  +  +  +  +  +  + );

   printf("%s %s %d\n",__FILE__,__FUNCTION__,__LINE__);

   test_1();

   return ;

}

打印：

2. 对于malloc动态内存分配，现在只是给出一个实例，让大家有一个感性的认识，要知道malloc主要用来动态开辟内存空间的，一般malloc都是和free配对的。以后会专门讲解的。下面的一个实例是动态开辟一个一维数组，比较简单。

# include <stdio.h>

# include <stdlib.h>

void input(int *array,int len)

{

    int i;

    printf("input %d numbers  ",len);

    for(i=; i<len; i++)

    {

        setbuf(stdin,NULL);

        scanf("%d",array+i);

    }

}

int main()

{

    int n=,i=;

    int *a, array[n];

    printf("input characters ");

    scanf("%d",&n);

    a = (int *)malloc(n*sizeof(int));

    input(a,n);

    printf("the characters you input are ");

    for(i=; i<n; i++)

        printf("%d ",a[i]);

    printf("\n");

    printf("a = %p,array = %p\n",a,array);

    free(a);

        a = NULL;

    return ;

}

程序要注意几点：

在C99标准中，准许使用下面的做法，但是不推荐

int n = 0;

scanf(“%d”,&n);

int ch[n] ;

在两次连着输入的时候，注意清除键盘缓存，在linux下可以用setbuf(),在Windows下可以用fflush()等，关于清除缓存，以后会专门讲解。
再次强调，malloc一定要和free配对使用，如果申请的空间不释放，一次两次也许不会有什么错误，申请多了就会发生内存泄漏，系统崩溃等严重问题，所以不要抱有侥幸心理。释放之后，a就是一个野指针了，一般而言，要将其赋为空，这是一个很好的习惯，希望大家坚持。

3. 大家看看下面的程序的输出结果是什么？

# include <stdio.h>

int main()

{

     int a[]={0x10111213,0x20212223,0x30313233,0x40414243,0x50515253};

     printf("a[5]={0x10111213,0x20212223,0x30313233,0x40414243,0x50515253}");

     printf("\na = %p\n&a = %p\n",a,&a);

     printf("a+1 = %p\n&a+1 = %p\n",a+,&a+);

     printf("&a[0] = %p\n&a[0]+1 = %p\n",&a[],&a[]+);

     printf("\nsizeof(a) = %d\nsizeof(&a) = %d\n",sizeof(a),sizeof(&a));

     printf("sizeof(&a[0]) = %d\nsizeof(&a[5]) = %d\n",sizeof(&a[]),sizeof(&a[]));

     printf("sizeof(&a[10]) = %d\n

     sizeof(a[]) = %d\n\n",sizeof(&a[10]),sizeof(a[5]));  

     return ;

}

输入结果：

aaarticlea/jpeg;base64,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" alt="" />

为什么会这样呢？大家都知道a是一个数组名，准确的讲，a是该数组首元素的地址，而&a是什么呢？&a是整个数组的地址。就像一栋房子一楼的门卫室，如果门卫室坐落在***地方，则这个***既是门卫室的地址，也是整栋大楼的地址，它们的值相等，但是表示的意思不一样，这就解释了为什么a和&a都等于0xbff7aadc，而sizeof(a)等于20，sizeof(&a)却等于4，因为&a是一个指针变量，32位机下的都是占4个字节，由此，我们可以推出对于一位数组buf[]，我们想求出里面元素的个数可以使用sizeof(buf) / sizeof(buf[0])。

对于a+1和&a+1，a+1则是第二个元素即a[1]的地址，这里的1表示一个数组单元，0xbff7aadc+4=0xbff7aae0；&a+1则是a[4]的下一个地址，此时的1表示的整个数组单元, 0xbff7aadc+4*5=0xbff7aaf0。

大家会有疑问，我们数组是a[5]，应该最大为a[4]，怎么会有a[5]，a[10]啊？为什么没有产生溢出？因为在整个数组中我们只是申请了5个单元，虽然这5个单元后面的空间我们无法访问，但是，这些空间还是实实在在存在的啊！所以还是有地址的！

4. 下面的程序是实现简单的求m到n之间的素数，大家看看吧！

# include <stdio.h>

int prime(int n)

{

     int i,j;

    for(i=; i<=n; i++)

        if(n%i==)

            break;

        if(i==n)

            return ;

        else

            return ;

}

int main()

{

    int i,j,m,n;

    printf("Please input the Prime min and max limitation you want to calculate: ");

    scanf("%d,%d",&m,&n);

    printf("The Prime of %d to %d limitation are ",m,n);

    for(i=m; i<=n; i++)

        if(prime(i))

            printf("%d ",i);

    printf("\n");

    return ;

}

打印：

5. 大家说说，浮点数能进行自增和自减运算吗？答案是肯定的，不信？我们做个实例测试一下。

# include <head.h>

int main(int argc, const char *argv[])

{

        float i = 1.0;

        double j = 2.0;

        printf("i=1.0,++i = %f,j-- = %f\n",++i,j--);

        return ;

}

打印：

C语言深度学习——第一天的更多相关文章

【吴恩达课后测验】Course 1 - 神经网络和深度学习 - 第一周测验【中英】
[吴恩达课后测验]Course 1 - 神经网络和深度学习 - 第一周测验[中英] 第一周测验 - 深度学习简介和“AI是新电力”相类似的说法是什么? [ ]AI为我们的家庭和办公室的个人设备供电 ...
SIGAI深度学习第一集机器学习与数学基础知识
SIGAI深度学习课程: 本课程全面.系统.深入的讲解深度学习技术.包括深度学习算法的起源与发展历史,自动编码器,受限玻尔兹曼机,卷积神经网络,循环神经网络,生成对抗网络,深度强化学习,以及各种算法的 ...
C语言进阶学习第一章
1.在C语言里面使用scanf给某个变量赋值时候,如果成功返回1,失败返回0:测试代码如下: /***假如在键盘输入的不是整形数据,则输出0,否则输出1***/ void main() { int a ...
cousera 吴恩达深度学习第一课第二周作业过拟合的表现
上图是课上的编程作业运行10000次迭代后,输出每一百次迭代训练准确度和测试准确度的走势图,可以看到在600代左右测试准确度为最大的,74%左右, 然后掉到70%左右,再掉到68%左右,然后升到70 ...
【深度学习Deep Learning】资料大全
最近在学深度学习相关的东西,在网上搜集到了一些不错的资料,现在汇总一下: Free Online Books by Yoshua Bengio, Ian Goodfellow and Aaron C ...
碎片︱R语言与深度学习
笔者:受alphago影响,想看看深度学习,但是其在R语言中的应用包可谓少之又少,更多的是在matlab和python中或者是调用.整理一下目前我看到的R语言的材料: ---------------- ...
30个深度学习库：按Python、C++、Java、JavaScript、R等10种语言分类
30个深度学习库:按Python.C++.Java.JavaScript.R等10种语言分类包括 Python.C++.Java.JavaScript.R.Haskell等在内的一系列编程语言的深度 ...
重磅︱文本挖掘深度学习之word2vec的R语言实现
每每以为攀得众山小,可.每每又切实来到起点,大牛们,缓缓脚步来俺笔记葩分享一下吧,please~ --------------------------- 笔者寄语:2013年末,Google发布的 w ...
深度学习与人类语言处理-语音识别(part2)
上节回顾深度学习与人类语言处理-语音识别(part1),这节课我们将学习如何将seq2seq模型用在语音识别 LAS 那我们来看看LAS的Encoder,Attend,Decoder分别是什么 Lis ...

随机推荐

Java集合框架
集合框架体系如图所示 Java 集合框架提供了一套性能优良,使用方便的接口和类,java集合框架位于java.util包中, 所以当使用集合框架的时候需要进行导包. Map接口的常用方法 Map接口提 ...
本周psp（观众页面）
个人项目PSP(观众页面) 计划 30min 估计要用多长时间 3d 开发 5h 需求分析 1h 生成设计文档 1h 设计复审 50min 代码规范 20min 具体设计 40min 具体编码 3h ...
【转载】js 各种复制到剪贴板
一.实现点击按钮,复制文本框中的的内容 <script type="text/javascript"> function ...
Deep Learning 18：DBM的学习及练习_读论文“Deep Boltzmann Machines”的笔记
前言论文“Deep Boltzmann Machines”是Geoffrey Hinton和他的大牛学生Ruslan Salakhutdinov在论文“Reducing the Dimensiona ...
hibernate 和 myBatis 比较
Hibernate与 MyBatis的比较第一章 Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架,它出身于sf.net,现在已经成为Jbos ...
Failed: error processing document #281: unexpected EOF，往MongoDB当中插入json文件时出现的错误。
往MongoDB当中插入json文件时提示的错误(我的操作系统是win10): 当时的执行命令是:mongoimport -d test -c restaurants d://primer-datas ...
Table的行列合并
<table border="1" width="200" height="200"> <tr> <td ro ...
自动生成build.xml文件
使用Eclipse 自动生成 Ant的Build.xml 配置文件,选择要生成Build.xml文件的项目,鼠标右键, Export-> General -> Ant Buildfiles ...
logistic原理与实践
逻辑回归模型是一种将影响概率的不同因素结合在一起的指数模型,得到的是0~1之间的概率分布.自变量范围是,值域范围限制在0~1之间.在搜索广告.信息处理和生物统计中有广泛的应用.例如搜索广告的点击率预估 ...
Mongodb 副本集分片（二）---mongodb副本集部署脚本详解
分享下,最近做的一主一从一仲裁的示例,如有需要,大家可以扩展成一主两从一仲裁. 大家可以看到我的集群名字沿用了默认的neunnm,如果是其他的话大家注意修改. 需要辅助文件hosts.con ...

C语言深度学习——第一天

C语言深度学习——第一天的更多相关文章

随机推荐

热门专题