程序基本结构

#include <stdio.h> 指定头文件,想使用函数库中的函数必须指明

int main() // 程序入口
{
int a = 111, b = 222, sum;
sum = a + b;
printf("和是 %d\n", sum); // 输出语句,%d是十进制占位符
return 0;
}

常量变量标识符

常量
整型常量 1000 实型常量 12.34 12.34e2 字符常量
字符 's'
转义字符 \n \101(8进制)\x42(16进制) 字符串常量 "aa" 符号常量 #define PI 3.1415926
程序编译后替换所有PI 变量
先声明后使用 int a = 11;
常变量,不允许修改值 const int a = 111; 标识符
只能由数字,字母,下划线组成,开头必须是字母或者下划线

数据类型

整型类型

基本整型 int
Turbo C2.0中占用2个字节,Visual C++中占用4个字节 短整型 short int
Turbo C2.0中占用2个字节,Visual C++中占用2个字节 长整型 long int
long a = 111L;
Turbo C2.0中占用4个字节,Visual C++中占用4个字节 双长整型 long long int
Turbo C2.0中占用8个字节,Visual C++中占用8个字节 说明:以上几种数据类型,可以添加unsigned表示正值,如 unsigned int. 默认值signed,无符号类型的存储范围可以扩大一倍
注意,小数(实型)不能使用unsigned修饰 unsigned int a = 3;printf("%u\n", a); 字符型 char,占用一个字节,也可以添加unsigned修饰
char a = 'a';
printf("%c\n", a); 布尔型 bool,1代表真,0代表假
bool的使用需要引入标准库,#include <stdbool.h>
bool x = true; 如果不想引入标准库,可以直接使用_Bool x = 1; 使用sizeof可以得出类型的占用字节数 sizeof (int)

浮点类型(实型)

单精度浮点型 float,占用4个字节

双精度浮点型 double,占用8个字节
double a = 1;
printf("%.2lf\n", a); // 保留2位小数 长双精度浮点型 long double
Turbo C2.0中占用16个字节,Visual C++中占用8个字节

基本类型转换

基本数据类型可以进行强制类型转换,如
double a = 1;
float b = (float)a;

字符串

字符串不可修改,结束标志是 '\0'

char* str = "hello, world";

char const* s1 = "foobar"; 定义字符串的最佳实践

char* s = "Hello" ", " "World"; 字符串自动聚合

函数类型

int main()
{
int max(int x, int y); // 使用自定义函数之前,必须再定义一次
int a, b, c;
scanf_s("%d和%d", &a, &b); // 收集用户输入的数据,&是地址符,表示将输入的数据传递给变量
c = max(a, b);
printf("max=%d\n", c);
return 0;
}
int max(int x, int y) { // 定义函数
int z;
if (x > y) {
z = x;
}
else {
z = y;
}
return z;
} 空参数的函数定义
int min(void) { return 0; }
int min() {return 0;}

枚举类型 enum

enum test {
first = 1, second, third
};
enum test a = second;
printf("%d\n", a); // 2

数组类型

一维数组
int arr[10]; 声明
arr[0] = 10; 赋值 int arr[2] = { 10,11 }; 初始化
int arr[] = { 10,11 }; 二维数组
int arr[2][3]; 声明
arr[0][0] = 1; 赋值 int arr[2][3] = { {1, 2, 3}, {4, 5, 6} }; 初始化
int arr[2][3] = { 1, 2, 3, 4, 5, 6 };
int arr[][3] = { 1, 2, 3, 4, 5, 6 }; 字符数组
字符串的存储形式就是字符数组
char arr[] = "so easy"; 声明
char arr[] = { "so easy" }; 系统自动在数组末尾添加 '\0'
printf("%s\n", arr); 输入输出不需要地址符&
char arr[5];
scanf("%s", arr);
printf("%s\n", arr);

结构体类型

结构体的作用是声明自定义数据类型

基本使用

    struct Student
{
char name[10];
int age;
char sex[4];
} student1, student2; // 定义类型并声明变量 struct Class
{
char ClassName[10];
struct Student s; // 可以实现嵌套struct
}; struct Class class1 = { "初一10班", {"叶家伟", 10, "女"} }; // 声明变量,struct Class表示类型 printf("%s|%s|%d|%s\n", class1.ClassName, class1.s.name, class1.s.age, class1.s.sex); 结构体数组 struct stu
{
int a;
}; struct stu arr[3] = { {1},{2},{3} }; for (int i = 0; i < 3; i++) {
printf("%d\n", arr[i].a);
}

共用体类型

共用体类型和结构体类似,不过共用体中的成员共用内存空间,以最长的数据类型所占的空间为主

union test
{
int i;
float j;
char c;
}; union test a; a.i = 99; printf("%d\n", a.i); // 99
printf("%f\n", a.j); // 0.000000
printf("%c\n", a.c); // c 共用体类型只能对一个成员赋值

字符串函数

puts
输出字符数组
char arr[] = "so ea\0sy";
puts(arr); gets
输入字符数组
char arr[5];
gets(arr); // 注意输入aaaa,系统默认末尾添加\0表示5个字符 strcat
需要 #include <string.h>
字符数组拼接,将结果放到第一个参数中
char arr[12] = "nihao";
char arr1[6] = "buhao";
strcat(arr, arr1);
puts(arr); // "nihaobuhao" strncat
需要 #include <string.h>
指定拼接字符个数
strncat(arr, arr1, 2); // "nihaobu" strcpy
需要 #include <string.h>
给字符数组赋值
char arr[5];
strcpy(arr, "aa"); char arr[5], arr1[5] = "bb";
strcpy(arr, arr1); strncpy
需要 #include <string.h>
给字符数组赋值指定个数字符
char arr[5], arr1[5] = "abcd";
strncpy(arr, arr1, 2);
arr[2]='\0';
puts(arr); // "ab" sprintf
格式化字符串
char str [50];
sprintf (str, "格式化后的字符串: %s = %i", "1+1",2);
printf ("%s\n", str); // 格式化后的字符串: 1+1 = 2 snprintf
指定字符长度
使用snprintf(b, sizeof(b), "%s", a); strcmp
用来比较两个字符串的大小
char arr[5] = "111", arr1[5] = "222";
int result = strcmp(arr, arr1);
英文字母小写比大写大,排在后面的比前面大
arr大于arr1的,函数返回正整数,小的返回负整数,相等返回0
A的ascll码是65
a的ascll码是97 strncmp
指定比较字符的个数
printf("%i\n", strncmp("ABC","AB", 3)); strcasecmp
比较,不区分大小写
printf("%i\n", strcasecmp("AB","aB")); strncasecmp
指定字符个数比较
printf("%i\n", strncasecmp("ABC","aB", 2)); strlen
需要 #include <string.h>
返回字符串实际长度
char arr[5] = "111";
int result = strlen(arr); strlwr
转小写
char arr[5] = "AAA";
strlwr(arr);
printf("%s\n", arr); strupr
转大写 atoi
需要 #include <stdlib.h>
字符串转数值
printf("%i\n", atoi("a1a")); // 0
printf("%i\n", atoi("1a")); // 1 strchr
需要 #include <string.h>
查找第一个匹配的元素,并且截取所有后面的字符
char *result = strchr("abcba", 'b');
printf("%s\n", result); // bcba strrchr
需要 #include <string.h>
查找第一个匹配的元素,并且截取所有前面的字符
char *result = strrchr("abcba", 'b');
printf("%s\n", result); // ba strspn 查找匹配段长度
printf("%i\n", strspn("abcdef", "abd")); //2 strcspn
需要 #include <string.h>
查找第一个匹配字符的索引位置
printf("%i\n", strcspn("abcdef", "bd")); // 1 strtod
取double数值
char *ptr;
double ret = strtod("111.1agc", &ptr);
printf("%f,%s\n", ret, ptr); // 111.100000,agc

运算符

算术运算符

    + - *
/ 实数相除得双精度浮点,整数相除得整数部分,负数相除向零靠拢
% ++ -- 关系运算符 < <= > >= == != 优先级,从上到下依次降低
!
算术运算符
< <= > >=
== !=
&&
||
= 逻辑运算符 逻辑与 a != b && 1 != 2
逻辑或 a != b || 1 == 2
逻辑非 !a 等价于 a == 0 逗号操作符 计算左操作表达式,不管它的返回值,整个表达式的返回值由最右边的操作表达式计算后的结果决定
int x = 42, y = 42;
printf("%i\n", (x *= 2, y)); // 42

流程控制语句

if...else...

a>b?a:b

switch结构
char a = 'c';
switch (a)
{
case 'a': printf("a"); break;
case 'b': printf("b"); break;
default: printf("no"); break;
} while(...){...}
do{...}while(...) for (int i = 0; i < 100; i++) { }
for(sumk = 1, k = 1; k < 10; k++, sumk += k)
printf("\%5d\%5d\\n", k, sumk); break 立即跳出循环
continue 终止本次循环

输入输出语句

printf

常用的格式字符

    d或者i
有符号十进制整数,long使用ld表示,long long使用lld表示
int a = 11111;
printf("%8d\n", a); // 制定输出占8列
printf("%5d\n", a); c
用来输出字符
char a = 'a';
printf("%c\n", a); s
用来输出字符串
printf("%s\n", "aa"); f
用来输出实型数据
默认小数位数6位
double a = 1;
printf("%f\n", a); 1.000000 指定小数位数
double a = 1111;
printf("%0.10f\n", a); e
用来输出指数
double a = 1111;
printf("%e\n", a); 1.111000e+03
printf("%0.2e\n", a); 1.11e+03 o 用来输出8进制整数 x 用来表示16进制整数 u 用来表示无符号10进制整数 g 用来输出浮点数,自动选择f或者e,谁输出的长度短,就选谁

scanf

scanf("%d,%d", &a, &b);         // 输入 1,2 这种格式获取数据
scanf("%d%d", &a, &b); // 输入 1 2 这种格式获取数据

putchar和getchar

输出字符
putchar('a'); 输入字符
char a, b;
a = getchar();
b = getchar(); // 输入gd,然后按enter键

变量和函数的存储类别

变量的存储类别

局部变量的存储类别

    auto变量
函数调用完毕自动释放变量的存储空间,局部变量默认都是auto变量,auto关键字可以省略
将变量存储在动态存储区
auto a = 1; static变量
函数调用完毕后不销毁,保留原始值 static int a = 1;
将变量存储在静态存储区 register变量
某一变量读写频繁,可以定义成register将值存在cpu的寄存器中
目前系统可以自动完成这一功能 全局变量的存储类别 extern扩展全局变量作用域
void fn1() {
extern int a; // 将变量的作用域扩展到此处
printf("%d\n", a);
}
int a = 1; 在其他c文件中,同样可以使用extern关键字,直接调用其他文件定义的全局变量 如果想限制其他文件访问此文件的全局变量,可以直接 static int a = 1; 这里的static关键字,仅仅用来限定作用域,不会改变存储区

函数的存储类别

默认是extern,此关键字可以省略不写
将作用域限定在当前文件,加static限定即可

指针

创建指针变量

int a = 1;

int *b = &a;        // 创建指针变量,&a用来表示整型数据的地址

printf("%d\n", *b); // 通过*b访问指针变量b对应的变量

指针变量在数组中的应用

int arr[] = { 1,2,3,4,5 };
int *p1 = arr, *p2 = &arr[0];
printf("%o\n", p1); // 105374130
printf("%o\n", p2); // 105374130 int *p = (int [2]){ 2, 4 }; // 指向数组的第一个元素 数组名代表数组首元素的地址,即 arr == &arr[0] 指针变量的加减运算 当指针指向数组元素时,指针变量的加减运算才有意义 地址加整数 int arr[] = { 1,2,3,4,5 };
int *p1 = &arr[0];
int *p2 = p1 + 1; // 访问数组的下个元素,+1 相当于加一个数组元素所占用的字节数
printf("%d\n", *p2); // 2
指针变量十进制值 p1 -> 5241000 p2 -> 5241004 地址减地址
p2 - p1; // 1 表示p2对应的元素和p1对应的元素相隔的距离 地址加地址,无意义 利用指针快速遍历数组 int arr[] = { 1,2,3,4,5 }, *p;
for (p = arr; p < arr + 5; p++) {
printf("%d", *p);
}
c语言中访问数组的[]其实是一个语法糖,arr[i] 等价于 *(arr + i),也就是说,p[i] 等价于 *(p + i)
使用技巧
*p++
*++p 先进行++运算,然后进行*计算 在二维数组中使用指针 int arr[][2] = { {1,2}, {3,4} };
printf("%d\n", *(arr + 1)); // 9174020
printf("%d\n", *(arr[0] + 1)); // 2 arr表示二维数组第一行的地址等价于arr[0],arr[0]表示第一行第一列的地址等价于arr[0][0]
注意,arr 和 arr[0] 内存地址是一样的,但是数据类型不一样
int (*p2)[2] = arr; 代表一维数组,表示二维数组中行的指针

指针变量在字符串中的使用

字符串其实就是字符数组
char arr[] = "c language is so easy";
printf("%c\n", *arr); // c 数组名代表字符串第一个字符的地址 使用指针表示字符串
char *arr = "c language is so easy"; // 最好加上const
printf("%s\n", arr); 复制字符串
char *str = "c language is so easy", str1[50];
int i;
for ( i = 0; *(str + i) != '\0'; i++) {
*(str1 + i) = *(str + i);
}
*(str1 + i) = '\0';
printf("%s\n%s\n", str, str1);

指针变量在函数中的使用

基本使用

    int main()
{
int fn(int);
int (*p)(int) = fn; // 声明函数指针变量并赋值
printf("%d\n", (*p)(1)); // (*p)(1) 和 p(1) 效果一样
return 0;
}
int fn(int a) {
return ++a;
} 函数作为另一个函数的参数 int main()
{
void fn1(int (*fun)(int));
int fn(int);
fn1(fn);
return 0;
}
int fn(int a) {
return ++a;
}
void fn1(int (*fun)(int)) {
printf("%d\n", fun(2));
} 函数的返回值是指针 int main()
{
char *fn();
char *p = fn();
printf("%s\n", p);
return 0;
}
char *fn() {
char *str = "c language is so easy";
return str;
}

指针变量在结构体的使用

结构体指针的使用

    struct stu
{
int a;
};
struct stu demo = { 1 };
struct stu *p = &demo;
printf("%d\n", demo.a); // 1
printf("%d\n", (*p).a); // 1
printf("%d\n", p->a); // 1 结构体指针数组的使用 struct stu arr[3] = { {1}, {2}, {3} }, *p;
for (p = arr; p < arr + 3; p++) {
printf("%d\n", (*p).a);
}

指针的其他应用

指针数组
数组中的每一个元素可以是指针
char* arr[] = { "a", "b", "c" };
printf("%c\n",**arr); // a 指向指针数据的指针变量
char* arr[] = { "a", "b", "c" }, **p;
for (int i = 0; i < 3; i++) {
p = arr + i;
printf("%s\n", *p);
} main函数的参数
int main(int length, char* params[])
{
for (int i = 0; i < length; i++) {
printf("%s%c", *(params + i), (i == (length- 1)?'\n':' '));
}
return 0;
}
通过命令行输入 .\ConsoleApplication1.exe 1 2 3 a b c
length得到的值是7,params就是参数的指针数组 动态内存分配
c语言的非静态局部变量存储在动态存储区,这个存储区称为栈
c语言允许用户自定义内存动态存储区,这个存储区称为堆,通过指针来引用,c提供下面的库函数来实现这一功能
需要导入#include<stdlib.h> malloc函数
用来开辟动态存储区
malloc(100); // 创建100个字节的空间,返回的指针为void类型 calloc函数
用来创建50个4个字节长度的连续空间
calloc(50, 4); // 返回的指针为void类型 realloc函数
用来将开辟的动态存储区重新划分
void *p = calloc(50, 4);
realloc(p, 50); // 将p指向的存储区重新规划成50个字节大小的存储区,返回的指针为void类型 free函数
释放已经开辟的动态存储区
void *p = calloc(50, 4);
free(p); // 无返回值 注意
void类型的指针不能存储数据,使用之前必须重新分派类型,应当如下使用
int* p = (int*)malloc(100); // 简写, 使用demo
int* p = (int *)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
scanf("%d", p + i);
}
for (int i = 0; i < 5; i++) {
if (*(p + i) < 10) {
printf("%d\n", *(p + i));
}
}

typedef

typedef关键字用来给已知的数据类型取别名,用法如下

基本数据类型名替换
typedef int Integer;
Integer i = 111;
printf("%d\n", i); 结构体取别名
typedef struct {
int i;
} test;
test i = { 1 };
printf("%d\n", i.i); 数组取别名
typedef int arr[5];
arr test = { 1,2,3,4,5 };
printf("%d\n", test[0]); 指针取别名
int arr[5] = { 1,2,3,4,5 };
typedef int* p;
p test = arr;
printf("%d\n", *test); 函数指针取别名
int main()
{
void fn();
typedef void(*test)();
test f = fn;
f();
return 0;
}
void fn() { printf("%s\n", "调用了"); }

文件操作

打开文件

文件缓冲区:每一个正在使用的文件都会自动开辟一个文件缓冲区,用来存放临时数据

指向文件的指针变量 FILE* f;

打开文件
FILE* f = fopen("F:\\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0); // 此函数是终止程序,需要 #include<stdlib.h>
}
printf("%d\n", fclose(f));

权限控制

文本文件
r 只读,文件不存在则出错
w 只写,创建新文件
a 追加,文件不存在则出错
r+ 读写,文件不存在则出错
w+ 读写,创建新文件
a+ 读写,文件不存在则出错 二进制文件
rb 只读,文件不存在则出错
wb 只写,创建新文件
ab 追加,文件不存在则出错
rb+ ...
wb+ ...
ab+ ... 提示:带b的和不带b的区别,不带b的会把\n转化成\r和\n

标准流

系统已经定义了3个流的指针变量
标准输入流 stdin
标准输出流 stdout
标准出错输出流 stderr

关闭流

调用fclose函数可以将文件缓冲区中的数据输出到磁盘中,然后再撤销文件信息区
fclose(f);

读写字符

写字符fputc,简写 putc
FILE* f = fopen("F:\\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
printf("%d\n", fputc('a', f)); // 写字符,成功则返回字符,不成功返回-1,即EOF
printf("%d\n", fclose(f)); // 关闭文件流成功返回0,不成功返回-1,即EOF 读字符fgetc,简写 getc
FILE* f = fopen("F:\\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
printf("%d\n", fgetc(f)); // 读字符,成功则返回字符,不成功返回-1,即EOF
printf("%d\n", fclose(f));

复制文件

FILE* in = fopen("F:\\demo.txt", "r");
FILE* out = fopen("F:\\demo1.txt", "w");
if (in == NULL || out == NULL) {
perror("Error");
exit(0);
}
char ch = fgetc(in); // 读取输入流第一个字符
while (!feof(in)) { // 判断输入流是否已到末尾,等价于 while (ch != EOF)
fputc(ch, out);
ch = fgetc(in); // 读取下一个字符
}
fclose(in);
fclose(out);

读写字符串

写字符串fputs
FILE* f = fopen("F:\\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
fputs("c language is so easy", f); // 执行成功,返回0,不成功,返回EOF
fclose(f); 读取字符串fgets
FILE* f = fopen("F:\\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
char str[50];
fgets(str, 23, f); // 读取22个字符,并且存到str中,如果遇到换行符\n或者EOF,就结束读取,其中\n是会读到结果中的,执行成功返回地址,不成功返回NULL
fclose(f);
printf(str);

格式化读写字符串

格式化写
FILE* f = fopen("F:\\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
float i = 1; int j = 2;
fprintf(f, "%.2f, %d", i, j);
fclose(f); 格式化读
FILE* f = fopen("F:\\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
float i; int j;
fscanf(f, "%f, %d", &i, &j);
fclose(f);
printf("%f, %d\n", i, j);

二进制方式读写数据

写数据fwrite
struct test
{
int i;
} t = { 1 };
FILE* f = fopen("F:\\demo.dat", "wb");
if (f == NULL || fwrite(&t, sizeof(struct test), 1, f) != 1) { // fwrite函数返回值是读取数据的个数
perror("Error");
exit(0);
}
fclose(f); 读数据fread
struct test {
int i;
} t;
FILE* f = fopen("F:\\demo.dat", "rb");
if (f == NULL || fread(&t, sizeof(struct test), 1, f) != 1) { // fread函数返回值是写数据的个数
perror("Error");
exit(0);
}
printf("%d\n", t.i);

控制文件位置标记

将位置移动到开头
FILE* f = fopen("F:\\demo.txt", "w+");
if (f == NULL) {
perror("Error");
exit(0);
}
fputs("c language is so easy", f);
char str[50];
rewind(f); // 将文件位置指针挪到开头
fgets(str, 23, f); // c language is so easy
printf(str);
fclose(f); 随意移动指针
以上面demo为例
SEEK_CUR
fseek(f, -5L, SEEK_CUR); 以当前位置为准将位置向左移动5个字节
fgets(str, 23, f); // " easy"
SEEK_SET
fseek(f, 5L, SEEK_SET); 以开始位置为准将位置向右移动5个字节
fgets(str, 23, f); // 'guage is so easy'
SEEK_END 表示结尾 获取文件当前指针位置
int i = ftell(f); // 相对于文件起始位置
if (i == -1L) { // 获取不到返回-1L
printf("error\n");
}
else {
printf("%ld\n", i);
}

检查错误

ferror函数
当调用各种输入输出函数时,如果出现错误ferror返回非0值
printf("%d\n", ferror(f)); clearerr函数
当文件读写出错,要调用 clearerr(f); 清空文件读写错误标志

c语言相关知识点解析的更多相关文章

  1. C语言特殊知识点解析

    1 数组 1.1 概念 数组是指某种数据类型,在内存上按照顺序存储.中括号([ ])是数组的标识,中括号内的数值标识该种数据类型变量的个数,中括号也有取值的作用. 1.2 数组使用 int a[10] ...

  2. java.util.Date 与 java.sql.Date 相关知识点解析

    问:java.sql.Date 和 java.util.Date 有什么区别?   答:这两个类的区别是 java.sql.Date是针对 SQL 语句使用的,它只包含日期而没有时间部分,一般在读写数 ...

  3. 学Android开发,入门语言java知识点

    学Android开发,入门语言java知识点 Android是一种以Linux为基础的开源码操作系统,主要使用于便携设备,而linux是用c语言和少量汇编语言写成的,如果你想研究Android,就去学 ...

  4. 知名互联网公司校招 Java 开发岗面试知识点解析

    天之道,损有余而补不足,是故虚胜实,不足胜有余. 本文作者在一年之内参加过多场面试,应聘岗位均为 Java 开发方向.在不断的面试中,分类总结了 Java 开发岗位面试中的一些知识点. 主要包括以下几 ...

  5. Java 面试知识点解析(二)——高并发编程篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

  6. Java 面试知识点解析(三)——JVM篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

  7. Java 面试知识点解析(四)——版本特性篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

  8. Java 面试知识点解析(六)——数据库篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

  9. [ Java面试题 ]Java 开发岗面试知识点解析

    如背景中介绍,作者在一年之内参加过多场面试,应聘岗位均为 Java 开发方向. 在不断的面试中,分类总结了 Java 开发岗位面试中的一些知识点. 主要包括以下几个部分: Java 基础知识点 Jav ...

随机推荐

  1. 使用ZooKeeper实现Java跨JVM的分布式锁(优化构思)

    一.使用ZooKeeper实现Java跨JVM的分布式锁 二.使用ZooKeeper实现Java跨JVM的分布式锁(优化构思) 三.使用ZooKeeper实现Java跨JVM的分布式锁(读写锁) 说明 ...

  2. CUDA初试

    1.基本概念 CUDA,全称是Compute Unified Device Architecture,意即统一计算架构,是NVIDIA推出的一种整合技术,开发者可以利用NVIDIA的GeForce 8 ...

  3. 内存保护机制及绕过方案——从堆中绕过safeSEH

    1.1    SafeSEH内存保护机制 1.1.1    Windows异常处理机制 Windows中主要两种异常处理机制,Windows异常处理(VEH.SEH)和C++异常处理.Windows异 ...

  4. 如何拿到半数面试公司Offer——我的Python求职之路(转载)

    从八月底开始找工作,短短的一星期多一些,面试了9家公司,拿到5份Offer,可能是因为我所面试的公司都是些创业性的公司吧,不过还是感触良多,因为学习Python的时间还很短,没想到还算比较容易的找到了 ...

  5. Ceph与OpenStack整合(仅为云主机提供云盘功能)

    1. Ceph与OpenStack整合(仅为云主机提供云盘功能) 创建: linhaifeng,最新修改: 大约1分钟以前 ceph ceph osd pool create volumes 128 ...

  6. LeetCode OJ:Two Sum(两数之和)

    Given an array of integers, find two numbers such that they add up to a specific target number. The ...

  7. react antd layout sider

    import React from 'react'; import {Link, withRouter} from 'react-router-dom'; import {Layout, Menu, ...

  8. 《模式 工程化实现及扩展 (设计模式 C#版)》 - 书摘精要

    (P3) 面向对象的典型原则可以划分为两类 —— “面向类”的和“面向包”的: “面向类”的,包括:SRP —— 单一职责原则:OCP —— 开放封闭原则:LSP —— 里氏替换原则:DIP —— 依 ...

  9. vsftp中的local_umask和anon_umask

    umask是unix操作系统的概念,umask决定目录和文件被创建时得到的初始权限umask = 022 时,新建的目录 权限是755,文件的权限是 644umask = 077 时,新建的目录 权限 ...

  10. Android OpenCSV

    OpenCSV https://sourceforge.net/projects/opencsv/ 使用参考 http://stackoverflow.com/questions/16672074/i ...