精华内容
下载资源
问答
  • #define _CRT_SECURE_NO_WARNINGS #include #include //结构体 typedef struct _Teacher { char name[64];//名字 int age;//年龄 char *title;//职称 }Teacher; //打印函数 int printfArray(Teacher *... if (p
    #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;
    }

    展开全文
  • 1.Java变量 1.1.变量(variable)的含义 * 变量相当于自然语言中的代词。比如“您好”中的“您”就是代词,我们为什么用代词?是因为我 们可以跟每个人说“您好”,通用、方便。同理,编程中也是一样的,变量让程序...

    个人微信:yinhaoliang6

    1.Java变量

    1.1.变量(variable)的含义 *

    变量相当于自然语言中的代词。比如“您好”中的“您”就是代词,我们为什么用代词?是因为我
    们可以跟每个人说“您好”,通用、方便。同理,编程中也是一样的,变量让程序语 言表达更方便。举个例子:

    Person p ; //代表了一个人
    int age; //代表了岁数
    

    1.2. Java 中的变量 *

    在 Java 中,每一个变量属于一种类型(type),声明变量时,变量所属的类型位于变量名之前,以分号";"结束.
    Java 是强类型语言,在使用变量时有如下规则:
    a. 变量必须声明,并且初始化以后才能使用。
    b. 变量必须有明确的类型(type)。
    c. 变量不能重复定义。
    变量声明,如下我们定义了几个变量,分别声明为 Java 中的几种不同类型,如下图 所示:
    image
    变量初始化后才能使用,如上图中仅仅声明不叫初始化,初始化包括两部分:声明和赋值.在使用变量时,如果只声明不赋值,会导致编译错误

    1.3.变量的作用域 *

    在声明的地方开始,到块结束为止;离开变量的作用域结束,变量将回收。
    image
    在上边的例子中,score 的作用域是 if{…}块(注意对语句块的理解,一般为一个{}之内表示一个语句块),
    当在该诧句块之外调用该变量时,就会报编译错诨,因为变量已经不存在了.

    1.4.变量的命名规则 *

    数字不可以作为开头但可以作为内容
    image

    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 进制转换

    image
    二进制、八进制、十进制、十六进制之间的转换

    二进制与十进制之间的转换

    十进制转二进制

    方法为:十进制数除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.什么是变量变量 在程序运行过程中值是允许改变的量。 变量可以保存程序运行时用户输入的数据、特定运算的结果以及要在窗体上显示的一段数据等。简而言之,变量是用于跟踪几乎所有类型信息的简单工具。 ...

    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 - usernamesu 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 变量,在上一篇文章中已经有简单提及相关概念和用法,这一篇主要对 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. 语句1,语句2 一定是在语句3的前面执行,但不保证语句1,语句2的执行顺序。
    2. 语句4,语句5 一定是在语句3的后面执行,但不保证语句4,语句5的执行顺序。
    3. 语句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 等。

    这里写图片描述

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

    1. read&load 从主内存复制变量到当前工作内存。
    2. use&assign 执行代码,改变共享变量的值。
    3. 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

    本文原创首发于微信公众号 [ 林里少年 ],欢迎关注第一时间获取更新。
    这里写图片描述

    展开全文
  • 2.6 在新建系统变量里添加 JAVA_HOME的变量名,变量值为自己安装java时的路径 2.7 编辑Path变量,在变量值最后输入 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; 2.8 有CLASSPATH变量就编辑,没有就新建,在...
  • 也可以把一个变量a赋值给另一个变量b,这个操作实际上是把变量b指向变量a所指向的数据,例如下面的代码: a = 'ABC' b = a a = 'XYZ' print b 最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'?...
  • //有n个结构体变量内含学生学号、姓名、3门课程的成绩,要求输出平均成绩最高的学生信息(学号、姓名、三门课成绩、平均成绩) #include <stdio.h> typedef struct stu_info{ int num; char name[20]; ...
  • win10下Android Studio和SDK下载、安装和环境变量配置 ------made by siwuxie095 转自I-T枭https://me.csdn.net/hahahhahahahha123456 1、首先必须安装Java JDK ...
  • 函数上下文的变量对象初始化只包括 Arguments 对象 在进入执行上下文时会给变量对象添加形参、函数声明、变量声明等初始的属性值,注意,这里是分先后顺序的 在代码执行阶段,会再次修改变量对象的属性值 巩固例子 ...
  • //有n个结构体变量内含学生号, 姓名和三门课成绩。要求输出平均成绩最高学生的信息。 #include #define N 3 struct Student { int num; char name[20]; float socre[3]; float aver; }; void input(struct ...
  • 定义变量 1.CSS 的变量声明和使用 定义 3 个变量,:root 使得所有人可访问 :root{ --base:yellow; --spacing:10px; --blur:10px; } 使用上面定义的变量作为属性值: img{ filter:blur(var(--blur)); ...
  • #include<stdio.h> #include<math.h> #include<string.h> struct Student { long num; char name[20]; float score[3]; float aver; }; ... printf("请输入各学生的信息...
  • 有n个结构体变量内含学生学号、姓名和3门课程的成绩。要求输出平均成绩最高的学生的信息(包括学号、姓名、3门课程成绩和平均成绩) 代码: #include<stdio.h> #define N 3 struct Student { int num; ...
  • C程序设计(第四版) 谭浩强 例9.7 个人设计例 9.7 有n个结构体变量内含学生学号、姓名和3门课程的成绩。要求输出平均成绩最高的学生的信息(包括学号、姓名、3门课程成绩和平均成绩)。代码块:#include <...
  • 有n个结构体变量内含学生学号、姓名和3门课程的成绩。要求输出平均成绩最高的学生的信息(包括学号、姓名、3门课程成绩和平均成绩)。 解题思路: 将n个学生的数据表示为结构体数组。按照功能函数化的思想,分别用3...
  • //返回平均成绩最大的结构体成员变量 void print ( struct Student stu ) ; //实现输出结构体成员变量的数据 struct Student stu [ 3 ] , * p = stu ; input ( p ) ; print ( max ( p ) ) ; }...
  • #include<stdio.h> # define N 3 struct Student {int num; char name[20]; float score[3]; float aver; }; int main() { void input(struct Student stu[]); struct S...
  • //有n个结构体变量内含学生学号、姓名和3门课程的成绩。 //要求输出平均成绩最高的学生的信息(包括学号、姓名、3门课程成绩和平均成绩) #include <stdio.h> #define N 3 struct Student { int num; char ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,898
精华内容 6,759
关键字:

内含变量