C - 基本使用

最新推荐文章于 2024-04-27 13:04:07 发布
最新推荐文章于 2024-04-27 13:04:07 发布
阅读量367 收藏
点赞数
分类专栏： C/C++ 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yan13507001470/article/details/119521602
版权
这篇博客详细介绍了C语言的基础知识，包括基本数据类型如int、double、float等的使用，以及如何通过指针进行内存地址操作，展示了如何通过指针修改变量值和数组元素。此外，还讲解了函数的运用，如函数指针和回调函数，以及字符串的操作，如获取长度、比较和查找子串。最后，涉及到了文件操作，包括读写文件和获取文件大小。
摘要由CSDN通过智能技术生成

include

#include <stdio.h>
int main() {
    printf("Hello, World!你好\n");
    return 0;
}

// #include
// <> 寻找系统的资源
// "" 寻找自己写的资源
// .h .hpp 声明文件，头文件
// .c .cpp 实现文件

// int main() 是主函数，程序从这里开始执行

// return 0; 终止 main() 函数，并返回值 0

基本数据类型

#include <stdio.h>

int main() {
    printf("Hello, World!你好\n");

    int i = 100;
    double d = 200;
    float f = 300;
    long l = 400;
    short  s = 500;
    char c = 'd';

    char * str = "hello";

    printf("i value : %d\n", i);
    printf("d value : %lf\n", d);
    printf("f value : %f\n", f);
    printf("l value : %d\n", l);
    printf("s value : %d\n", s);
    printf("c value : %c\n", c);
    printf("str value: %s\n", str);

    return 0;
}
// 运行结果：
//Hello, World!你好
//i value : 100
//d value : 200.000000
//f value : 300.000000
//l value : 400
//s value : 500
//c value : d
//str value: hello

sizeof 获取类型的存储字节大小

#include <stdio.h>

int main() {
    printf("int 占的字节数: %d\n", sizeof(int));
    printf("double 占的字节数: %d\n", sizeof(double));
    printf("float 占的字节数: %d\n", sizeof(float));
    printf("long 占的字节数: %d\n", sizeof(long));
    printf("short 占的字节数: %d\n", sizeof(short));
    printf("char 占的字节数: %d\n", sizeof(char));

    return 0;
}
//int 占的字节数: 4
//double 占的字节数: 8
//float 占的字节数: 4
//long 占的字节数: 4
//short 占的字节数: 2
//char 占的字节数: 1

#include <stdio.h>
int main() {
    int arrInt[3] ;
    double arrDouble[3] ;
    
    printf("%d\n", sizeof(arrInt)); // 12   ==  3 * 4   int的字节数为4，数组数量为3故乘3
    printf("%d\n", sizeof(arrDouble)); // 24  == 3 * 8  double字节数为8

    return 0;
}

指针

    指针是内存地址，指针变量用来存放内存地址的变量。

    %p 地址输出的占位
    & 取出地址

指针占用的内存大小为：4个字节（32位）。

#include <stdio.h>
int main() {
    int i = 100;
    printf("i value: %d\n", i);

    /*
     * 指针取值
     */
    // 指针变量声明
    int *ip;
    ip = &i; // &i，取出 变量i 的地址
    printf("变量地址为：%p\n", ip);
    printf("变量的值为：%d\n", *ip);

    return 0;
}

//i value: 100
//变量地址为：004FFA88
//变量的值为：100

通过指针修改值

#include <stdio.h>

int main() {
    int i = 100;

    int * ip = &i;

    * ip = 300;

    printf("i value : %d\n", i); // i value : 300

    return 0;
}

函数方式去操作修改值

#include <stdio.h>
void change(int i){
    i = 200;
}
void change2(int *i){
    * i = 300; // 指针操作修改
}
int main() {
    int i = 100;

    change(i);
    printf("i value : %d\n", i); // i value : 100

    change2(&i);
    printf("i value : %d\n", i); // i value : 300

    return 0;
}

函数方式，互换值

#include <stdio.h>

void change(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}
int main() {
    int a = 100;
    int b = 200;

    change(&a, &b);

    printf("a value : %d\n", a); // a value : 200
    printf("b value : %d\n", b); // b value : 100

    return 0;
}

二级指针

指针存放的是内存地址；自己也有内存地址。

    一级指针：*
    二级指针：**
    三级指针：***

#include <stdio.h>
int main() {
    int a = 100;
    int * a_p = &a;
    int ** a_p_p = &a_p;
    
    printf("a_p的值为: %p, a_p_p的值为：%p\n", a_p, a_p_p); 
    //a_p的值为: 0073FE98, a_p_p的值为：0073FE8C
    
    printf("获取最终的值为：%d\n", **a_p_p); 
    //获取最终的值为：100
    
    return 0;
}

数组与数组指针

#include <stdio.h>
int main() {
    int arr[] = {1,2,3,4};
//    错误方式
//    for (int i = 0; i < 4; ++i) {
//    }

//  正确的方式
    int i = 0;
    for (i = 0;  i < 4; i++) {
        printf("arr is %d\n", arr[i]);
    }

    return 0;
}

数组的内存地址 == 第一个元素的内存地址

#include <stdio.h>
int main() {
    int arr[] = {1,2,3,4};
    
    printf("arr is %p\n", arr); // arr is 00F3FB3C
    printf("arr is %p\n", &arr); // arr is 00F3FB3C
    printf("arr is %p\n", &arr[0]); // arr is 00F3FB3C

    return 0;
}

采用指针遍历数组 - 指针挪动

#include <stdio.h>
int main() {
    int arr[] = {1,2,3,4};

    int * arr_p = arr;

    int i;
    for (i = 0;  i < 4; i++) {
//        // 方式1
//        printf("arr_p is %d\n", arr_p[i]);
//
//        // 方式2
//        printf("arr_p is %d\n", *(arr_p + i));

        // 方式3
        printf("arr_p is %d\n", *arr_p);
        arr_p ++;

    }

    return 0;
}

循环给数组赋值

#include <stdio.h>
int main() {
    int arr[4] ;

    int * arr_p = arr;

    // 赋值
    int i;
    for (i = 0;  i < 4; i++) {
        *(arr_p + i) = 100 + i;
    }

    // 遍历
    i = 0;
    for (i = 0;  i < 4; i++) {
        printf("arr_p is %d\n", *(arr_p + i));
    }

    return 0;
}

函数指针

#include <stdio.h>

void add(int num1, int num2){
    printf("num1 + num2 = %d \n", (num1 + num2));
}

void mins(int num1, int num2){
    printf("num1 - num2 = %d \n", (num1 - num2));
}

// 回调到 add 和 mins方法
// void(*method)(int, int) 声明 函数指针
//     void为返回值
//     (*method)函数名
//     (int, int)参数
void operate(void(*method)(int, int), int num1, int num2){
    method(num1, num2);
    printf("operate函数的 method指针是：%p\n", method);
}

int main() {
    operate(add, 100, 10);
    operate(mins, 100, 10);

    printf("main函数的 add指针是：%p\n", add);
    printf("main函数的 mins指针是：%p\n", mins);
    return 0;
}
//num1 + num2 = 110
//operate函数的 method指针是：0037123F
//num1 - num2 = 90
//operate函数的 method指针是：0037123A
//main函数的 add指针是：0037123F
//main函数的 mins指针是：0037123A

回调

#include <stdio.h>

void callBackMethod(char * fileName, int current, int total){
    printf("%s process：%d/%d\n", fileName, current, total);
}

void compress(char * fileName, void(*callBackP)(char *, int, int)){
    callBackP(fileName, 30, 100);
}

int main() {

    // 方式1
    // void(*call)(char *, int, int) = callBackMethod;
    // 方式2
    void(*call)(char *, int, int);
    call = callBackMethod;

    compress("a.jpg", call);


    return 0;
}

// result:
// a.jpg process：30/100

字符串 char *

a）定义字符串的两种方式

#include <stdio.h>
int main() {
    // 方式1
    // \0 给printf用的，遇到 \0 才结束
    char str[] = {'a', 'b', 'c', 'd', 'e', '\0'};
    str[2] = 'p';
    printf("第一种方式：%s\n", str); // 第一种方式：abpde

    // 方式2
    char * str2 = "abcde";
//    str2[2] = 'z';   // 这里会崩溃掉，不允许这么操作
    printf("第二种方式：%s\n", str2); // 第二种方式：abcde

    return 0;
}

b）获取字符串长度 - 方式1

#include <stdio.h>

void getLenOfChar(int * lenResult, char * string){
    int count = 0;
    while (*string){ // 不为 \0 一直循环
        string++;
        count ++;
    }
    *lenResult =  count;
}

int main() {
    // \0 给printf用的，遇到 \0 才结束
//    char str[] = {'a', 'b', 'c', 'd', 'e', '\0'};
    char * str = "abcde";

    int lenValue = 0;
    getLenOfChar(&lenValue, str);
    printf("长度为：%d\n", lenValue); // 5

    return 0;
}

c）获取字符串长度 - 方式2

#include <stdio.h>
#include <string.h>

int main() {
    char * str = "abcde";

    // 方式2
    int lenValue = strlen(str);
    printf("长度为：%d\n", lenValue); // 5

    return 0;
}

d）字符串的转换 - 字符串转成int 和 double

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

int main() {
    char * str = "23.91";

    int result = atoi(str);
    if (result){ // 非零 即true
        printf("转换后：%d\n", result); // 转换后：
    }

    double d = atof(str);
    printf("value:%lf\n", d); // 23.910000

    return 0;
}

e）字符串的比较 - strcmp/strcmpi

strcmp 区分大小写
strcmpi 不区分大小写

#include <stdio.h>
#include <string.h>

int main() {
    char *str1 = "hello";
    char *str2 = "Hello";

    int result = strcmp(str1, str2); // 区分大小写
    result = strcmpi(str1, str2); // 不区分大小写

    if (result) {  // 0 相同，非0不同
        printf("不相同的  %d\n", result); // 不相同的
    } else {
        printf("相同的  %d\n", result);
    }

    return 0;
}

f）字符串的查找 - strstr

#include <stdio.h>
#include <string.h>

int main() {
    char *str1 = "helloWorldHelloJava";

    char * pop = strstr(str1, "H");

    if (pop) {  // 非NULL查到了
        printf("包含了，查到了  %s\n", pop); // 查H    HelloJava
    } else {
        printf("没包含，没查到  %s\n", pop); // 查w    (null)
    }

    // 求索引
    int index = pop - str1;
    printf("索引为：%d\n", index);
    // 查w  索引为：-6918216
    // 查H  索引为：10

    return 0;
}

g）字符串的拼接 - strcpy/strcat

#include <stdio.h>
#include <string.h>

int main() {
    char *str1 = "helloWorld";
    char *str2 = "helloJava";

    char dest[25]; // 定义一个容器

    strcpy(dest, str1); // 拷贝
    strcat(dest, str2); // 拼接
    printf("拼接后：%s\n", dest); // 拼接后：helloWorldhelloJava

    return 0;
}

h）字符串的大小写转换 - tolower/toupper

#include <stdio.h>
#include <ctype.h>

void lower(char * dest, char * str){
    char * tempStr = str; // 临时指针，避免破坏str
    while (*tempStr){
        * dest = tolower(*tempStr);
        tempStr++;
        dest++;
    }
    *dest = '\0'; // 避免打印系统值，乱码
}

int main() {
    char *str1 = "helloWorld";

    char dest[35]; // 容器

    lower(dest, str1);

    printf("转换后：%s\n", dest); // 转换后：helloworld

    return 0;
}

i）字符串的截取

#include <stdio.h>
#include <string.h>

void subStringAction1(char * result, char * str, int start, int end){
    char * temp = str;

    int count = 0;
    while (*temp){
        if (count >= start && count < end){
            *result = *temp;
            result++;
        }
        temp++;
        count++;
    }
}

void subStringAction2(char *result, char * str, int start, int end){
    for (int i = start; i < end; ++i) {
        *(result++) = *(str+i);
    }
}

void subStringAction3(char *result, char * str, int start, int end){
    strncpy(result, str + start, (end - start));
}

int main() {
    char * str = "helloWorld";

    char * result = "";
//    subStringAction1(result, str, 2, 5);
//    subStringAction2(result, str, 2, 5);
    subStringAction3(result, str, 2, 5);
    printf("结果为：%s\n", result);

    return 0;
}

int

a）获取int数组的长度

#include <stdio.h>

// 数组作为参数传递，会把数组优化成指针
void getLenOfIntArr(int * intArrLen, int arr[]){
    *intArrLen = sizeof(arr) / sizeof(int); // 1
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7};
    int len = 0;
    len = sizeof(arr) / sizeof(int);
    printf("方式1：arr 长度为：%d\n", len); // 7

    len = 0;
    getLenOfIntArr(&len, arr);
    printf("方式2：arr 长度为：%d\n", len); // 1

    return 0;
}

结构体

a）第1种写法

#include <stdio.h>
#include <string.h>

struct Dog{
    char name[10];
    int age;
    char sex;
};

int main() {

    struct Dog dog;

    strcpy(dog.name, "汪汪");
    dog.age = 1;
    dog.sex = 'm';

    printf("输出, name:%s, age:%d, sex:%c \n", dog.name, dog.age, dog.sex);
    // 输出, name:汪汪, age:1, sex:m

    return 0;
}

b）第2种写法

#include <stdio.h>
#include <string.h>

struct Dog{
    char name[10];
    int age;
    char sex;
} ddd = {"汪汪", 2, 'm'},
ddd2,
ddd3
;

int main() {
    printf("输出, name:%s, age:%d, sex:%c \n", ddd.name, ddd.age, ddd.sex);
    // 输出, name:汪汪, age:2, sex:m

    printf("输出, name:%s, age:%d, sex:%c \n", ddd2.name, ddd2.age, ddd2.sex);
    // 输出, name:, age:0, sex:

    strcpy(ddd3.name, "汪汪");
    ddd3.age = 3;
    ddd3.sex = 'm';
    printf("输出, name:%s, age:%d, sex:%c \n", ddd3.name, ddd3.age, ddd3.sex);
    // 输出, name:汪汪, age:3, sex:m

    return 0;
}

c）第3种写法

#include <stdio.h>

struct Study{
    char * studyContent;
};

struct Student {
    char name[10];
    int age;
    char sex;

    struct Study study;

    struct Play{
        char * playContent;
    } play;
};

int main() {

    struct Student student = {
            "张三", 21, 'M',
            {"学C"},
            {"play basketball"}};

    printf("输出, name:%s, age:%d, sex:%c, study:%s, play:%s \n",
           student.name,
           student.age,
           student.sex,
           student.study,
           student.play);


    return 0;
}

结构体指针

#include <stdio.h>
#include <string.h>

struct Student {
    char name[10];
    int age;
    char sex;
};

int main() {

    struct Student student = {"张三", 21, 'M'};
    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);

    struct Student * studentP = &student;
    studentP->age = 23;
    strcpy(studentP->name, "李四");
    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);
    
    return 0;
}

结构体数组

#include <stdio.h>

struct Student {
    char name[10];
    int age;
    char sex;
};

int main() {

    struct Student student[5] = {
            {"张1", 21, 'M'},
            {"张2", 22, 'M'},
            {"张3", 23, 'M'},
            {"张4", 24, 'M'},
            {"张5", 25, 'M'}
    };

    printf("输出, name:%s, age:%d, sex:%c \n",student[0].name, student[0].age, student[0].sex);
    // 输出, name:张1, age:21, sex:M

    struct  Student student2 = {"张22222", 22, 'M'};
    // student[1] = student2;
    * (student + 1) = student2;
    printf("输出, name:%s, age:%d, sex:%c \n",student[1].name, student[1].age, student[1].sex);
    // 输出, name:张22222, age:22, sex:M

    return 0;
}

结构体别名 - 方式1

#include <stdio.h>
#include <string.h>

struct Student {
    char name[10];
    int age;
    char sex;
};

// 给结构体取别名
typedef struct Student Student;

// 给结构体指针取别名
typedef Student * StudentP;

int main() {

    Student student = {"张1", 21, 'M'};

    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);
    // 输出, name:张1, age:21, sex:M

    StudentP studentP = &student;
    studentP->age = 23;
    strcpy(studentP->name, "李四");
    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);
    // 输出, name:李四, age:23, sex:M

    return 0;
}

结构体别名 - 方式2

#include <stdio.h>
#include <string.h>

// 给结构体取别名
typedef struct {
    char name[10];
    int age;
    char sex;
} Student;

int main() {

    Student student = {"张1", 21, 'M'};

    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);
    // 输出, name:张1, age:21, sex:M

    Student * studentP = &student;
    studentP->age = 23;
    strcpy(studentP->name, "李四");
    printf("输出, name:%s, age:%d, sex:%c \n",student.name, student.age, student.sex);
    // 输出, name:李四, age:23, sex:M

    return 0;
}

enum 枚举

#include <stdio.h>

enum CommentType {
    TEXT = 10,   // 后续枚举成员的值在前一个成员上加 1 即 TEXT 10, TEXT_IMAGE 11, IMAGE 12
    TEXT_IMAGE,
    IMAGE
};

int main() {

    enum CommentType type1 = TEXT;
    enum CommentType type2 = TEXT_IMAGE;
    enum CommentType type3 = IMAGE;

    printf("%d, %d, %d \n", type1, type2, type3); // 10, 11, 12

    return 0;
}

枚举别名

#include <stdio.h>

typedef enum {
    TEXT = 10,   // 后续枚举成员的值在前一个成员上加 1 即 TEXT 10, TEXT_IMAGE 11, IMAGE 12
    TEXT_IMAGE,
    IMAGE
} CommentType;

int main() {
    CommentType type1 = TEXT;
    CommentType type2 = TEXT_IMAGE;
    CommentType type3 = IMAGE;

    printf("%d, %d, %d \n", type1, type2, type3); //

    return 0;
}

文件的操作

r：读
a+：读 、追加写

rb 、 rw

读文件

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

int main(){
    FILE * file = fopen("C:\\xxx\\xxxx\\xxx\\test.txt", "r");

    if (!file){
        printf("打开文件失败，请检查！");
        exit(0);
    }

    // 定义缓存区域
    char buffer[10];
    // 缓冲区buffer   长度10  文件变量指针
    while (fgets(buffer, 10, file)){
        printf("%s", buffer);
    }

    // 关闭文件
    fclose(file);

    return 0;
}

写文件

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

int main(){
    FILE * file = fopen("C:\\xxx\\xxxx\\xxx\\test1.txt", "a+");

    if (!file){
        printf("打开文件失败，请检查！");
        exit(0);
    }

    // 写入
    fputs("This is xxxxxx \n", file);

    // 关闭文件
    fclose(file);

    return 0;
}

复制文件

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

int main(){
    FILE * srcFile = fopen("C:\\xxx\\xxx\\xxx\\test1.txt", "rb");
    FILE * destFile = fopen("C:\\xxx\\xxx\\xxx\\test2.txt", "wb");

    if (!srcFile || !destFile){
        printf("打开文件失败，请检查！");
        exit(0);
    }

    char buffer[514]; // 514 * 4 = 2048
    int len;

    // 容器buffer
    // 每次偏移多少
    // 容器大小  sizeof(buffer) / sizeof(int) 等价于 514
    while ((len = fread(buffer, sizeof(int), sizeof(buffer) / sizeof(int), srcFile)) != 0){
        fwrite(buffer, sizeof(int), len, destFile);
    }

    // 关闭文件
    fclose(srcFile);
    fclose(destFile);

    return 0;
}

获取文件大小

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

int main(){
    FILE * srcFile = fopen("C:\\xxx\\xxx\\xxx\\test1.txt", "rb");
    
    if (!srcFile){
        printf("打开文件失败，请检查！");
        exit(0);
    }

    fseek(srcFile, 0, SEEK_END);

    long file_size = ftell(srcFile);

    printf("字节大小size: %ld \n", file_size);

    // 关闭文件
    fclose(srcFile);

    return 0;
}

C函数速查手册 资源

下载地址（微云）：https://share.weiyun.com/c1QgcdwS

在这里插入图片描述

C参考手册

https://zh.cppreference.com/w/c

仰望XX
关注
专栏目录
C使用
Hu_yilang的博客
02-13 632
1.理解回调函数 https://blog.csdn.net/zhuwentao2150/article/details/51006347 2.pthread_cond_init() https://www.cnblogs.com/secondtonone1/p/5580203.html 3.attribute((visibility(“default”))) https://blog.csdn....
char数组和char指针应该注意的
beibaoke910的专栏
09-01 728
数组要么在静态区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命周期内保持不变，只有数组的内容可以改变。 指针可以随时指向其他类型的内存块，它的特征是“可变”，所以常用指针来操纵动态内存。指针远比数组灵活，但也更危险。 1.返回指向栈上的内存的指针 char * testStr1(){ char value[4] = "hello";...
理解 char*、char** 和 char*[] 的区别
cyt涛的博客
11-21 962
3. `char*[]`：`char*[]` 是一个字符串指针数组，也称为 C 字符串数组。它是一个一级指针数组，每个元素都是一个 `char*` 类型的指针，指向一个字符串。2. `char**`：`char**` 是一个指向指针的指针，也称为指向 C 字符串的指针数组。1. `char*`：`char*` 是一个指向字符的指针，也称为 C 字符串。需要注意的是，在 C 语言中，`char*[]` 和 `char**` 在某些上下文中可以互换使用，但它们的语义和用法略有不同。以上两种写法效果等同。
纯c中char*[]的处理
tiankong_的博客
09-26 641
要明确的几点：   1.以下是不行的 #include"stdio.h" #include int main() {     char * a=0;     scanf("%s",a);     printf("%s",a);     system("pause");     return 0; } 2.char a[100]={0};    char *b[100]={
c语言hash 存储代码,C语言 开放寻址法HASH表存储简单实现
weixin_42511053的博客
05-17 204
#include#include#include#include#include#include#define MAX_VALUE 5typedef struct hashNode{char *key;char *value;int flag;}Hash;typedef struct table{Hash *hashTable[MAX_VALUE];int size;}HashTable;Hash...
零基础入门C语言-王桂林 -v2-.pdf
06-07
本文档是一份关于C语言基础入门的电子书籍，由王桂林编写，主要...总结来看，本电子书籍是一套系统性的C语言入门教程，涵盖了从环境搭建、基本语法到编程思想的各个方面，非常适合完全没有编程基础的读者学习和使用。
Objective-C-2.0程序设计-基本的C语言特性.ppt
11-16
本讲座主要关注Objective-C 2.0中的基本C语言特性，这些特性对于理解Objective-C的底层工作原理至关重要。 13.1 数组 在Objective-C中，数组是一种数据结构，可以存储同一类型的多个值。数组通过索引来访问其元素，...
C语言-哈希算法基本操作.zip
06-20
在压缩包下附带了利用 C 语言开发的哈希表的运算方法（包括增、删、改、查）以及计算并显示哈希表的平均查找长度 ...非常适合学习数据结构 C 语言版的同学的学习和使用，也可用于课程设计。欢迎广大朋友的关注与下载。
C语言-iat-下载-me-test
最新发布
06-13
标题中的"C语言-iat-下载-me-test"暗示了这是一个关于C语言学习资源的集合，可能包含了一些测试或实例，用于帮助学习者提升在IoT（物联网）和嵌入式系统中使用C语言的能力。描述简单地说明了这是“c语言的基础资料”...
json-c-master_c语言项目_json-c-master_JSONC语言_json-c_
10-02
7. **内存管理**：由于C语言没有自动的垃圾回收机制，因此在使用`json-c`时，必须手动管理内存。了解何时调用`json_object_put`释放不再使用的JSON对象。 8. **编译和调试**：学会如何使用Makefile来编译和链接`...
c语言的一些程序
dpasdfjk66的博客
11-24 2314
c语言-浪漫程序员的浪漫 程序员的浪漫 #include<stdio.h> #include<windows.h> int main(){ float x,y,a; for(y=1.5;y>-1.5;y-=0.1){ for(x=-1.5;x<1.5;x+=0.05){ a=x*x+y*y-1; putchar(a*a*a-x*x*y*y*y<=0.0?'*':' '); } system("color 0c"); putchar
C++基础一：基本数据类型
weixin_63026364的博客
12-05 9240
C++基础一：基本数据类型
变量声明、类型转换、运算符优先级
weixin_44127337的博客
11-01 515
变量声名 2019-10-26 1、变量声名格式： 数据类型 变量名 = 初始化值 2、变量的分类： （1）整数类型：byte、short、int、long java的整型常量默认为int型，声明long型常量须后加‘l’或‘L’ (2)浮点类型：float、double 浮点型常量默认为double型，声明f...
C++基础（3） - 基本数据类型
weixin_44799144的博客
01-29 2028
C++基本数据类型
C++基本数据类型
LiYanHu0的博客
09-23 2138
C++day2 第一章 C++ 基本数据类型 文章目录C++day2前言一、整形二、实型-浮点型三、字符和字符串四、布尔类型五、附录-转义字符表总结 前言 C++基本数据类型详解 提示：以下是本篇文章正文内容，下面案例可供参考 一、整形 一个字节占8位 short（短整型 2字节） int（整型 4字节） long（长整型 4字节 在64位linux虚拟机里是8个字节） long long（长长整型 8字节） short a = 32768;
c++基本数据类型
weixin_56799061的博客
04-27 608
4. unsigned long：无符号长整型，通常占用4字节或8字节，范围为0到4294967295或0到18446744073709551615，取决于编译器和系统。5. unsigned long long：无符号长长整型，通常占用8字节，范围为0到18446744073709551615。3. unsigned int：无符号整型，通常占用4字节，范围为0到4294967295。- long：长整数，通常占用4字节或8字节，取决于编译器和系统。- long long：长长整数，通常占用8字节。
C++学习之基本数据类型
热门推荐
百锦再的博客
01-23 1万+
无符号整数类型（unsigned int、unsigned short、unsigned long、unsigned long long）是C++中的整数类型，用于存储大于等于零的整数值。在进行无符号整数类型之间的转换时，可以进行隐式转换，但要注意溢出问题和类型大小。在进行有符号整数类型和无符号整数类型之间的转换时，最好使用显示的类型转换操作符，以明确转换的意图并避免潜在的错误。当将一个有符号整数类型的值赋给无符号整数类型时，如果数值在无符号类型的表示范围内，则值不变；如果需要更高的精度，则可以考虑使用。
数据类型：C++中的基本数据类型
weixin_47712251的博客
06-30 965
在C++中，基本数据类型用于存储不同类型的数据。本篇博客介绍了字符型和数值类型的基本数据类型，包括charshortintlonglong longfloatdouble和。通过正确选择和使用合适的数据类型，可以更有效地处理和操作数据。了解这些基本数据类型的特点和范围，将有助于编写高效且准确的C++程序。
C++从入门到精通——基本数据类型
ZKY1998的博客
06-16 1199
C++基本数据类型 在C++中，基本数据类型包含以下几种： 空类型：表示空指针类型，即nullptr_t类型，占用一个指针的大小(平台相关)。 布尔类型：表示真或假，即true或是false(占用一个字节)。 字符类型：表示单一的字符。根据不同的宽度，又可以细分为以下三种： char：单字节字符集中的一个字符。 char16_t：该类型用于表示utf16的一个码点，宽度为两个字节。 char32_t：该类型用于表示utf32的一个码点，宽度为四个字节。 wchar_t：该类型用于表示适合于编译
使用LCC-win学习C语言基础
“LCC-win带的C语言教程” 这篇教程主要介绍了使用LCC-win编译器学习C语言的基础知识。...通过学习，读者可以掌握C语言的基本语法、程序结构、类型系统以及控制流，并理解编译和运行C程序的基本流程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值