#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

//结构体
typedef struct _Teacher
{
	char name[64];//名字
	int age;//年龄
	char *title;//职称
}Teacher;

//打印函数
int printfArray(Teacher *pArr,int len)
{
	if (pArr == NULL)
	{
		return -1;
	}
	for (int i = 0; i < len; i++)
	{
		printf("老师的名字叫%s,年纪%d,职称%s\n", pArr[i].name, pArr[i].age, pArr[i].title);
	}
}

//创建内存
Teacher * createMem()
{
	Teacher *pArray = NULL;
	pArray = (Teacher *)malloc(3*sizeof(Teacher));
	if (pArray == NULL)
	{
		return NULL;
	}
	//关键的一步
	//pArray.title = (char *)malloc(60*sizeof(char));错误的
	for (int i = 0; i < 3; i++)
	{
		pArray[i].title = (char *)malloc(sizeof(100));
	}
	
	return pArray;
}

//释放
void freeMem(Teacher *pArray)
{
	if (pArray)
	{
		for (int i = 0; i < 3; i++)
		{
			if ((pArray[i]).title != NULL)
			{
				free((pArray[i]).title);
				(pArray[i]).title = NULL;
			}
		}
		free(pArray);
		pArray = NULL;
	}
}

int main()
{
	Teacher *pArray = NULL;//创建结构体对象
	pArray = createMem();

	int i = 0;

	if (pArray == NULL)
	{
		printf("分配内存有问题\n");
		return -1;
	}

	for (i = 0; i < 3; i++)
	{
		printf("第%d老师的姓名:", i + 1);
		scanf("%s", pArray[i].name);
		printf("第%d老师的年纪:", i + 1);
		scanf("%d", &pArray[i].age);
		printf("第%d老师的职称:", i + 1);
		scanf("%s", pArray[i].title);
	}

	printfArray(pArray,3);

	freeMem(pArray);
	pArray = NULL;
	freeMem(pArray);
	system("pause");
	return 0;
}

个人微信:yinhaoliang6
1.Java变量
1.1.变量（variable）的含义 *
变量相当于自然语言中的代词。比如“您好”中的“您”就是代词，我们为什么用代词？是因为我

们可以跟每个人说“您好”，通用、方便。同理，编程中也是一样的，变量让程序语 言表达更方便。举个例子:
Person p ; //代表了一个人
int age; //代表了岁数

1.2. Java 中的变量 *
在 Java 中，每一个变量属于一种类型（type），声明变量时，变量所属的类型位于变量名之前,以分号";"结束.

Java 是强类型语言，在使用变量时有如下规则：

a. 变量必须声明，并且初始化以后才能使用。

b. 变量必须有明确的类型（type）。

c. 变量不能重复定义。

变量声明，如下我们定义了几个变量，分别声明为 Java 中的几种不同类型，如下图 所示：



变量初始化后才能使用，如上图中仅仅声明不叫初始化，初始化包括两部分：声明和赋值.在使用变量时,如果只声明不赋值,会导致编译错误
1.3.变量的作用域 *
在声明的地方开始，到块结束为止；离开变量的作用域结束，变量将回收。



在上边的例子中，score 的作用域是 if{…}块（注意对语句块的理解，一般为一个{}之内表示一个语句块）,

当在该诧句块之外调用该变量时，就会报编译错诨，因为变量已经不存在了.
1.4.变量的命名规则 *
数字不可以作为开头但可以作为内容


1.5. Java中的关键字与保留字
Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
Java 关键字列表 (依字母排序 共50组):

abstract, assert,boolean, break, byte, case, catch, char, class, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
Java 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。

byValue, cast, false, future, generic, inner, operator, outer, rest, true, var，goto，const, null
1.6 进制转换


二进制、八进制、十进制、十六进制之间的转换
二进制与十进制之间的转换
十进制转二进制
方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止.  150
二进制转十进制
方法为：把二进制数按权展开、相加即得十进制数.
二进制与八进制转换
二进制转八进制

方法为：3位二进制数按权展开相加得到1位八进制数。（注意事项，3位二进制转成八进制是从右到左开始转换，不足时补0).

八进制转成二进制

方法为：八进制数通过除2取余法，得到二进制数，对每个八进制为3个二进制，不足时在最左边补零。
二进制与十六进制之间的转换
二进制转十六进制

方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一。（注意事项，4位二进制转成十六进制是从右到左开始转换，不足时补0）

十六进制转二进制

方法为：十六进制数通过除2取余法，得到二进制数，对每个十六进制为4个二进制，不足时在最左边补零.
    public static void main(String[] args)
    {
        int i = 192;
        System.out.print(Integer.toBinaryString(i))   //输出2进制
        System.out.print(Integer.toHexString(i))      //输出16进制
        i = 0xf4;  //16进制
        System.out.print(i);   //默认按十进制输出
        i = 072;   //8进制     //默认按八进制输出
    }

1.什么是变量？
变量 在程序运行过程中值是允许改变的量。
变量可以保存程序运行时用户输入的数据、特定运算的结果以及要在窗体上显示的一段数据等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。

变量是用一串固定的字符来表示不固定值的一种方法

变量是一种使用方便的占位符，用于引用计算机内存地址.该地址可以存储Script运行时可更改的程序信息。使用变量并不需要了解变量在计算机内存中的地址，只要通过变量名引用变量就可以查看或更改变量的值。

变量：是内存地址的别名，是一个地址符（$USER）

在shell中变量是不能永久保存在系统中的，必须在文件中声明
2.变量的种类及变量定义方法
（1）环境级变量：只在当前shell中生效，开启新的shell不生效，当前shell关闭后变量会丢失
定义方法：export a=8

export—声明，共享


（2）用户级变量：写在用户家目录下的.bash_profile文件中，只针对当前用户生效
定义方法：

vim ~/.bash_profile

export b=9





source—不是刷新，而是读取添加
（3）系统级变量：写在系统的配置文件/etc/profile 或 /etc/profile.d 中，对所有用户生效
定义方法：

vim /etc/profile

export c=6




env 命令可查看系统中已定义的变量

切换用户时，使用su - username 与 su username 的区别
su -：加载/etc/bashrc文件，也加载/etc/profile文件，加载系统中的环境变量
su：只加载/etc/bashrc文件，不会加载/etc/profile文件，即不会加载系统的环境变量


3.变量名称规范
变量名称中通常包含大小写字母[ a-z/A-Z ]，数字[ 0-9 ]，下划线[ _ ]（不是必须的）
4.字符的转译及变量的声明




字符
说明




\
转义单个字符


""
弱引用，批量转义“”中出现的字符


''
强引用，批量转义‘’中出现的字符


${}
变量声明


''与""的区别：" " 不能转译 \，`，!，$，而 ‘ ’ 可以


5.变量值传递




字符
说明




$0
脚本名


$1
脚本后的第一串字符串


$2
脚本后的第二串字符串


$3
脚本后的第三串字符串


$#
脚本后所跟字符串的个数


$*
脚本后跟的所有字符串，模式为“1 2 3”


$@
脚本后跟的所有字符串，模式为“1” “2” “3”






$*与$@的区别如下：









6.利用命令执行结果设定变量
（1）$() = ``
hostname=$(hostname)

等效于
hostname=`hostanme`




（2）$?
$? 是命令在执行完后产生的退出值，范围是[ 0-255 ]

当 $?=0 时表示命令执行没有错误输出

$? 的值可以用 exit 命令执行，例如 exit 97




7.read 实现变量传递




命令
说明




read		WORD
将输入赋给变量WORD


read -s WORD1
将输入赋给变量WORD1，不回显


read -p "Please Input : " WORD2
显示Please Input : 并将输入赋给变量WORD2





8.Linux系统中命令别名的设定
alias命令
（1）环境级
alias xie='vim'
alias
xie /etc/passwd
bash		/*开启一个新环境*/
xie /etc/passwd		/*不能识别xie命令*/
exit


（2）用户级
vim /root/.bashrc

alias xie='vim'
source /root/.bashrc
xie		/*进入vim界面*/
su - student
xie		/*不能识别xie命令*/

source 不是刷新，而是读取文件中添加的信息，若文件中删除了信息，则不需要使用source命令






（3）系统级
vim /etc/bashrc

alias xie='vim'
xie
su - student
xie		/*可识别xie命令*/






（4）取消命令别名的设定
vim /etc/bashrc		/*系统级*/
	#alias xie='vim'
vim /root/.bashrc		/*用户级*/
	#alias xie='vim'
unalias xie		/*环境级*/






9.脚本中的函数
（1）函数的定义
函数 是一组命令，这些命令被赋予一个名称，该名称的作用类似于该组命令的句柄。 要执行函数中定义的这组命令，只需使用提供的名称调用该组命令即可。

脚本中的函数是把一个复杂的语句块定义成一个字符串的方法

函数：名称+动作
（2）函数的优点
<1>缩减脚本长度

<2>使脚本可循环运行

<3>提高程序的可读性和重用性
（3）函数的定义
方法一：
function_name ()
{
    statement1
    statement2
    ....
    statementn
}

方法二：
function function_name()
{
   statement1
   statement2
   ....
   statementn
}

（4）函数的调用
1>调用方法
用户就可以通过函数名来调用该函数。在Shell中，函数调用的基本语法如下：

function_name parm1 parm2
2>先定义后调用
3>对于同名的函数，后面的会覆盖前面的

  
「 天行健，君子以自强不息。地势坤，君子以厚德载物。」———《易经》


volatile 变量，在上一篇文章中已经有简单提及相关概念和用法，这一篇主要对 Volatile 变量的特性进行源码验证。验证它的涉及到的三个特性：


可见性
指令重排序
非原子性




volatile 之可见性验证

上一篇文章中，讲到 volatile 变量通常被当做状态标记使用。其中典型的应用是，检查标记状态，以确定是否退出循环。下面我们直接举个反例，源码如下：



    public class Volatile {

        boolean ready=true;  //volatile 状态标志变量

        private final static int SIZE = 10; //创建10个对象，可改变

        public static void main(String[] args) throws InterruptedException{

            Volatile vs[]=new Volatile[SIZE];

            for(int n=0;n<SIZE;n++)
                (vs[n]=new Volatile()).test(); 

            System.out.println("mainThread end");//调用结束打印，死循环时不打印
        }

        public void test() throws InterruptedException{
            Thread t2=new Thread(){
                public void run(){
                    while(ready);//变量为true时，让其死循环
                }
            };
            Thread t1=new Thread(){
                public void run(){
                    ready=false;
                }
            };
            t2.start();
            Thread.yield();
            t1.start();
            t1.join();//保证一次只运行一个测试，以此减少其它线程的调度对 t2对boolValue的响应时间 的影响
            t2.join();
        }
    }

其中，ready 变量是我们要验证的 volatile 变量。一开始 ready 初始化为 true,其次启动 t2 线程让其进入死循环；接着，t1 线程启动，并且让 t1 线程先执行，将 ready 改为 false。理论上来讲，此时 t2 线程应该跳出死循环，但是实际上并没有。此时 t2 线程读到的 ready 的值仍然为 true。所以这段程序一直没有打印出结果。这便是多线程间的不可见性问题,官方话术为: 线程 t1 修改后的值对线程 t2 来说并不可见。下图可以看到程序一直处于运行状态：



解决办法是：对变量 ready 声明为 volatile，再次执行者段程序，能够顺利打印出 “mainTread end”。volatile 保证了变量 ready 的可见性。



另外补充说明我这个例子用的 Java 版本：





volatile 之重排序问题说明

有序性：表示程序的执行顺序按照代码的先后顺序执行。通过下面代码，我们将更加直观的理解有序性。



int a = 1;
int b = 2;
a = 3;     //语句A
b = 4;     //语句B

上面代码，语句 A 一定在语句 B 之前执行吗? 答案是否定的。因为这里可能发生指令重排序。语句 B 可能先于语句 A 先自行。

什么是指令重排序？处理器为了提高运行效率，可能对输入代码进行优化，他不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是他会保证程序最终执行的结果和代码顺序执行的结果是一致的。

但是下面这种情况，语句 B 一定在 语句 A 之后执行。



int a = 1;
int b = 2;
a = 3;     //语句A
b = a + 3;     //语句B

原因是，变量 b 依赖 a 的值，重排序时处理器会考虑指令之间的依赖性。

当然，这个 volatile 有什么关系呢？ 

volatile 变量可以一定程度上保证有序性，volatile 关键字禁止指令重排序。



//x、y为非volatile变量
//flag为volatile变量

x = 1;        //语句1
y = 2;        //语句2
flag = true;  //语句3

x = 3;         //语句4
y = 4;       //语句5

这里要说明的是，flag 为 volatile 变量；能保证


语句1，语句2 一定是在语句3的前面执行，但不保证语句1，语句2的执行顺序。
语句4，语句5 一定是在语句3的后面执行，但不保证语句4，语句5的执行顺序。
语句1，语句2 的执行结果，对语句3，语句4，语句5是可见的。


以上，就是关于 volatile 的禁止重排序的说明。、



volatile 之非原子性问题验证

volatile 关键字并不能保证原子性，如自增操作。下面看一个例子：



public class Volatile{

    private volatile int count = 0;

    public static void main(String[] args) {

        final Volatile v = new Volatile();

        for(int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    v.count++;
                }

            }).start();
        }

        while(Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(v.count);
    }

}

这个程序执行的结果并没有达到我们的期望值，1000。并且每次的运行结果可能都不一样，如下图，有可能是 997 等。



来看下面一副图，分解自增操作的步骤。


read&load 从主内存复制变量到当前工作内存。
use&assign 执行代码，改变共享变量的值。
store&write 用工作内存数据刷新主内存相关内容。




但是，这一系列的操作并不是原子的。也就是在 read&load 之后，如果主内存 count 发生变化，线程工作内存中的值由于已经加载，不会产生对应的变化。所以计算出来的结果和我们预期不一样。

对于 volatile 修饰的变量，jvm 虚拟机只是保证从主内存加载到线程工作内存中的值是最新的。

所以，假如线程 A 和 B 在read&load 过程中，发现主内存中的值都是5，那么都会加载这个最新的值 5。线程 A 修改后写到主内存,更新主内存的值为6。线程 B 由于已经 read & load,注意到此时线程 B 工作内存中的值还是5， 所以修改后也会将6更新到主内存。

那么两个线程分别进行一次自增操作后，count 只增加了1，结果也就错了。

当然，我们可以通过并发安全类AomicInteger, 内置锁 sychronized,显示锁 ReentrantLock，来规避这个问题，让程序运行结果达到我们的期望值 1000.

1）采用并发安全类 AomicInteger 的方式：



import java.util.concurrent.atomic.AtomicInteger;

public class Volatile{

    private AtomicInteger  count = new AtomicInteger(0);

    public static void main(String[] args) {

        final Volatile v = new Volatile();

        for(int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    v.count.incrementAndGet();
                }

            }).start();
        }

        while(Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(v.count);
    }

}

2） 采用内置锁 synchronized 的方式：



public class Volatile{

    private int count = 0;

    public static void main(String[] args) {

        final Volatile v = new Volatile();

        for(int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    synchronized  (this) {
                        v.count++;
                    }
                }

            }).start();
        }

        while(Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(v.count);
    }

}

3）采用显示锁的方式



import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Volatile{

    private int count = 0;

    Lock lock = new ReentrantLock();

    public static void main(String[] args) {

        final Volatile v = new Volatile();

        for(int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                        v.lock.lock();
                        try {
                            v.count++;
                        }finally {
                            v.lock.unlock();
                        }
                }

            }).start();
        }

        while(Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(v.count);
    }

}



参考

http://www.cnblogs.com/dolphin0520/p/3920373.html 

https://blog.csdn.net/gao_chun/article/details/45095995 

https://blog.csdn.net/xilove102/article/details/52437581


  
本文原创首发于微信公众号 [ 林里少年 ]，欢迎关注第一时间获取更新。