本文是一篇关于C语言编程的实践记录，作者在整理和回顾代码的过程中，涉及到pandas在数据分析中的应用，以及C语言中的指针操作、数组、内存管理和数据类型的处理等基础知识。通过示例代码，作者探讨了如何在C语言中进行字符串操作、内存分配、指针数组、二进制运算等问题，并通过实际例子加深理解。
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
提示：这里可以添加本文要记录的大概内容：
记录2023年5月26日16:02:22日记，这次做的已经会不少了，但是还是会有不太理解的，继续迭代！
提示：以下是本篇文章正文内容，下面案例可供参考
一、整理的练习
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include "string.h"
#include <math.h>
using namespace std;
/********************************************************************************************
2023年5月26日15:55:49
今天和昨天两天把这边的代码重新看了一遍，做了一遍。还是有点头疼的。。。。
我觉得是因为这些都是头疼题，连续做，所以很头疼吧
头疼的时候去下面溜一圈，就想到，整理题目后再去回顾一遍也不是意见容易的事啊，
但是总归这是一个正确的学习方法，就是回顾，将之前不会做的题目做会，那么这就是进步啊！
我再把这个题目整理到csdn上，csdn也是一个好的便于回顾的平台。
********************************************************************************************/
struct TEST{
int a:5;
int b:7;
int c:3;};
struct A {
unsigned int a;
unsigned short b;
char c[];
};
int test = 12;
static int test2 = 10;
void intAndUnsignedOperation();
int niukePractise()
{
//这个编程题是计算字符串中有几个目标单词
char word[1000] = {"\n"};
char target;
int wordLen = 0;
int times = 0;
//printf("printf a string\n");
gets(word);
//printf("printf a charactor\n");
scanf("%c",&target);
wordLen = strlen(word);
for(int i = 0; i < wordLen; i++)
{
if( (word[i] == target) || (abs(word[i] - target) == 32) )
{
times++;
}
}
printf("%d",times);
return 0;
}
void test6()
{
char p[10];
strncpy(p, "thisisteststring", 20);
strncpy(p, "hello", 5);
printf("%p,%s\r\n", p,p); //hellosteststring √ strncpy不会在结尾添加结束符\0
char p2[10];
strncpy(p2, "thisisteststring", 10);
strncpy(p2, "hello", 5);
printf("%p,%s\r\n", p2,p2);
// 0061FDFE,hellosteststring
// 0061FDF4,hellostesthellosteststring ①由此可见展示向下生长的，即地址是由高地址向低地址申请。②strncpy不会在结尾加\0，没有\0的printf会栈溢出，一致打印直到有\0。③由此可见strncpy也不是安全函数
A *tmp = (A*)malloc (sizeof(A) + 100);
printf("sizeof(tmp):%zu",sizeof(tmp)); //106 错 4 √
printf("sizeof(*tmp):%zu",sizeof(*tmp)); //8
printf("\n");
int a = 1;
switch (a > 2) {
case 0:
printf("case 0");
case 1:
printf("case 1");
case 2:
printf("case 2");
default:
printf("default"); //012default √
}
char* charPoint = "Hello world";
charPoint = "This is a test";
printf("%s\n",charPoint); //This is a test,指针指向另一片内存？
int aa = -100;
unsigned int bb = 1;
printf("%d\n",aa + bb); //-99 打印有符号
cout << aa + bb << endl; //4294967179 打印无符号
printf("%u\n",aa + bb); //4294967179 打印无符号
//-100 源码 1000 0000 0000 0000 0000 0000 0110 0100
//-100 反码 1111 1111 1111 1111 1111 1111 1001 1011
//-100 补码 1111 1111 1111 1111 1111 1111 1001 1100
//1 补码 0000 0000 0000 0000 0000 0000 0000 0001 相加
// 1111 1111 1111 1111 1111 1111 1001 1101 (补码) //内存中存储方式，如果通过反码-补码方式可以方向解析出-99。如果被隐式转换成无符号，那么通过计算得到4294967179
if((int)(aa+bb) < 0) //-99小于0
{
printf("itis ok\n"); //itis ok
}
int flag = -1;
unsigned int tempY = 12;
int y = tempY * flag;
printf("%d\n",y); // -12
cout << tempY * flag << endl; //4294967284 涉及二进制相乘
// -1 源码 1000 0000 0000 0000 0000 0000 0000 0001
// -1 反码 1111 1111 1111 1111 1111 1111 1111 1110
// -1 补码 1111 1111 1111 1111 1111 1111 1111 1111
// 12 补码 0000 0000 0000 0000 0000 0000 0000 1100
// 相乘 1111 1111 1111 1111 1111 1111 1111 0100 转换成无符号就是4294967284
if(tempY * flag < 0)
{
printf("AAAA\r\n");
}
else
{
printf("BBBBB\r\n"); //BBBBB
}
if(y < 0)
{
printf("AAAA\r\n"); //AAAA
}
else
{
printf("BBBBB\r\n");
}
printf("y:%d\r\n",y); //-12
float fa = 1.2435;
float fb = 1.2435;
if(fa == fb)
{
printf("float is equal");
}
if(fabs(fa-fb) < 0.0001)
{
printf("float is equal2");
}
printf("\n");
double PI = 3.14159;
double baseVal = 1.0E100;
double addVal = baseVal + PI;
printf("baseVal = %2.2f\n",baseVal); //1.00E100 ×
printf("addVal = %f\n", addVal); //1.0E100 ×
printf("%1.5f \n", addVal - baseVal); //0 ×
//ERROR
return;
}
void ptrTest()
{
int array[] = {6,7,8,9,10};
int *ptr;
ptr = array;
*(ptr+2) += 2;
printf("ptrTest:%d,%d\n",*ptr, *(ptr+2)); //6 10
}
void memoryTest()
{
char buf1[8];
char buf2[3];
printf("buf1 address:%p\n",buf1); //栈地址
printf("buf2 address:%p\n",buf2); //栈地址 比buf1地址低4个字节
printf("test address:%p\n",test); //静态存储区 比buf1地址低4个字节 静态存储区存储全局变量和局部静态变量。未初始化全局变量存在bss段
printf("test2 address:%p\n",test2);
int *ptr = (int*)malloc(sizeof(int));
printf("ptr address:%p\n",ptr);
gets(buf2);//注意这里对buf2进行赋值
printf("buf2:%s\n",buf2);
printf("buf1:%s\n",buf1);
char buf3[5];
char buf4[4];
scanf("%s",&buf4);
printf("buf3:%s\n",buf3);
printf("buf4:%s\n",buf4);
}
void testAddress()
{
//指针数组这边之前很少用，也不太理解
int array[100] = {0, 1, 2};
typedef int (*ARRAY)[100];
int *p1 = array;
ARRAY p2 = &array; //这个没有理解
int *p5 = p1 + 1;
//int *p3 = &array;
printf("%p\n",p1);
printf("%p\n",p2); //这个地址和p1一样，没有理解, 然后想了一下，数组名就是数组首地址，即下标为0的元素，指针数组，第一个元素指向array第一个元素地址，也就是array首地址，所以和p1、array地址一样
printf("%p\n",p2[0]);
printf("%p\n",&p2[0]); //这个就是ARRAY自己首地址。 打印发现前四个地址一样！ 不理解
printf("%p\n",p5); //比p1多四个字节
printf("%d\n",p1); //无意义
printf("%d\n",p2);
printf("%d\n",p5);
printf("%d\n",p1[0]); //无意义
printf("%d\n",*(p2[0]));
printf("%d\n",p2[0]);
printf("%d\n",p5[0]);
}
void testduiqi()
{
#pragma pack(2)
struct str1
{
//char p;
int a;
char b;
float c;
//char d[7];
};
struct str1 testStr1;
//ERROR
printf("%d\n",sizeof(str1)); //12
printf("%d\n",sizeof(testStr1)); //12
char a= -3;
char b = 127;
char c= a+b;
printf("%d\n",c); //124
int e = 2;
char f = 128;
printf("f=%d\n",f); //这边验证char型f存入128后是啥结果，打印-128,目前看是将1000 0000存入内存，然后按有符号解释为-128
int g = f + e; //-126
int i = e + (int)f; //1111 1111 1111 1111 1111 1111 1000 0000 , 1111 1111 1111 1111 1111 1111 1000 0010, 通过反解析即-126
printf("g=%d\n",g); //×
printf("%i=d\n",i);
//-126 10 + 1000 0000 = 1000 0010-> 11111111 11111111 11111111 1000 0010(整型提升)->11111111 11111111 11111111 1000 0001(补码)-> 10000000 00000000 00000000 0111 1110(原码) = -126//
int h = 2022; //0x07E6 //x86 小端 内存中存储方式为E6 07
char x = 127;
int y = 4;
int z = x + y;
printf("z=%d\n",z); //131
x += y;
printf("x=%d\n",x); //-125 ERROR
// your code goes here
getchar();
}
void test11()
{
int i = 0, *p, m =0;
int x[] = {5,4,3,2,1};
p=x;
if(p+1 <= x + 4)
{
printf("%d, %d\n",p+1, x + 4);
}
for(p=x, i=1; p+i <= x+4; i++)
{
cout<<*(p+i)<<endl;
for(i = 0; i < 4; i++)
{
m+=p[i];
//cout << "\t" << m << endl;
printf("\t%d\n",m);
}
if(p + i <= x + 4)
{
int d = 0;
}
}
int h = 0; //ERROR 结论：第二个for循环只能进一次。这里有两个地方需要注意，第一、p + i <= x + 4比较的是地址。第二、在第二个for循环里i是累加的，而且第一个for循环第二次想进入的时候，i是5，不符合条件，便进不了for循环
}
int digui(int num)
{
return num;
}
void testDigui()
{
int num = 5;
int total = 1;
while(num)
{
total = total * digui(num);
num--;
}
printf("total:%d\n",total);
}
int digui2(int month)
{
printf("month:%d\n",month);
int retNum = 0;
if(month == 1)
{
retNum = 2;
printf("1ret2:%d\n",retNum);
}
else if(month == 2)
{
retNum = 2;
printf("2ret2:%d\n",retNum);
}
else
{
retNum = digui2(month - 1) + digui2(month - 2);
printf("ret:%d\n",retNum);
}
printf("return:%d\n",retNum);
return retNum;
}
void testDigui2()
{
int month = 4;
int total = 0;
total = digui2(month);
printf("total:%d\n",total);
}
#define TEST_STRING "hello test string"
void DefineTest()
{
char *stringCopy = NULL;
// stringCopy = (char*)malloc(sizeof(char) * 100);
int len = strlen(TEST_STRING);
printf("%d\n",len); //17
printf("%d\n",sizeof(TEST_STRING)); //18
memcpy(stringCopy, TEST_STRING, sizeof(TEST_STRING)); //把換行符也拷贝进去。启动运行发现程序死机了，指针stringCopy没有分配空间
printf("%s\n", stringCopy);
getchar();
}
void charTest()
{
//如果输入是"hello world"
// char word[101] = {"\0"};
// if(fgets(word, 101, stdin) != NULL) { // fgets也是从标准输入读入一行，但是它会保留换行符然后在换行符后边加入'\0';
// int len = strlen(word);
// printf("fgetsstrlen:%d\n",len); //12 11加换行符
// printf("fgetssizeof:%d\n",sizeof(word)); //101
// printf("%s",word);
// }
char word2[101] = {"\0"};
// while(gets(word2) != NULL) { // gets是从标准输入读入一行，遇到换行符停止并且把换行符替换为'\0';
// int len = strlen(word2);
// printf("getslen:%d\n",len); //11
// }
char word3[101] = {"\0"};
if (scanf("%s",word3) != EOF) { // scanf遇到第一个空格就已经结束了第一次读取。因为缓冲区还有一个b，所以第二次读取立马进行了(此句存疑)。
int len = strlen(word3);
printf("scanflen:%d\n",len);
printf("%s\n",word3);
}
getchar();
}
int test1202() { //可能是某个编程题
char word[501] = {'\0'};
int count = 0;
int dictArray[127] = {0};
while(gets(word) != NULL)
{
int len = strlen(word);
for(int i = 0; i < len; i++)
{
if(word[i] >= 1 && word[i] <= 127)
{
dictArray[word[i]] = 1;
}
}
for(int i = 0; i < 127; i++)
{
if(dictArray[word[i]] == 1)
{
count++;
}
}
printf("%d", count);
}
getchar();
return 0;
}
void getWordByDict(char* word)
{
for(int i = 0; i < strlen(word); i++)
{
for(int j = i + 1; j < strlen(word); j++)
{
char temp;
if(word[i] > word[j])
{
temp = word[i];
word[i] = word[j];
word[j] = temp;
}
}
}
}
void getTwoDimenWordByDict(char **word, int len)
{
for(int i = 0; i < len; i++)
{
for(int j = i + 1; j < len; j++)
{
char temp[101] = {'\0'};
//if((*(word + i))[0] > (*(word + j))[0])
//if(strcmp((*(word+i)), (*(word+j))) > 0) //异常
if(strcmp((*(word+i)), (*(word+j))) > 0)
{
// strcpy(temp, word[i]);
// strcpy(word[i], word[j]);
// strcpy(word[j], temp);
// memcpy(temp, word[i], 101);
// memcpy(word[i], word[j], 101);
// memcpy(word[j], temp, 101);
memcpy(temp, (*(word+i)), 101);
memcpy((*(word+i)), (*(word+j)), 101);
memcpy((*(word+j)), temp, 101);
}
}
}
int a = -1;
if(-1)
{
printf("a=-1, then enter if judge\n");
}
for(int i = 0; i < len; i++)
{
printf("%s\n",word[i]);
}
getchar();
//以上的代码一开始使用的是memcpy,在牛客网运行是没办法对字符串数组排序的，当时就觉得很奇怪，很无语！ 但是在codeblock上运行就没有问题
//然后就各种尝试
}
//一维数组传参
int testOneDimensionalArray() {
int nums = 0;
char word[101] = {'\0'};
while (scanf("%d", &nums) != EOF) { // 注意 while 处理多个 case
for(int i = 0; i < nums; i++)
{
scanf("%s",word);
getWordByDict(word);
printf("%s",word);
}
}
return 0;
}
int testTwoDimensionalArrayBack() {
char twoDimenArray2[][101] = {"cap", "two", "boat", "boot"};
int nums = 0;
char word[101] = {'\0'};
int len = sizeof(word);
printf("len:%d\n",len);
printf("twoDimenArray2:%s\n",twoDimenArray2);
while (scanf("%d", &nums) != EOF) { // 注意 while 处理多个 case
char twoDimenArray[][101] = {'\0'}; //这个地方是有问题的，比如我在控制台输入hello\world\this\happy这四个字符串时，通过watchs观察，twoDimenArray里面存了hello,然后twoDimenArray2里面存了world。栈溢出了。可以把twoDimenArray2打印一下看看
for(int i = 0; i < nums; i++)
{
scanf("%s",twoDimenArray[i]);
}
printf("twoDimenArray2:%s\n",twoDimenArray2); //然后twoDimenArray2里面存了world。这边打印出了world。分析一下，栈是向下生长的(每次申请的变量是在下面。因为栈顶地址最高，下一个申请的变量地址越来越低，此称之为向下生长)。
//然后twoDimenArray2先申请，twoDimenArray再申请，twoDimenArray内存大小为101，存第二个字符串的时候内存不足，栈溢出，world存到了高地址的twoDimenArray2中。现在实验申请twoDimenArray[4][101],这样使用memcpy也没有问题。
//事实在牛客网上验证确实是可以的。所以这个题目不正常，不是strcpy和memcpy的使用问题，而是内存问题和二维数组的使用不熟的问题。
//所以最好的就是在堆上申请二维数组
//getTwoDimenWordByDict(twoDimenArray, nums);
}
}
//修改后
int testTwoDimensionalArray() {
char twoDimenArray2[][101] = {"cap", "two", "boat", "boot"};
int nums = 0;
char word[101] = {'\0'};
int len = sizeof(word);
printf("len:%d\n",len);
while (scanf("%d", &nums) != EOF) { // 注意 while 处理多个 case
//char twoDimenArray[4][101] = {'\0'};
//char (*twoDimenArray)[101] = (char (*)[101])malloc(101 * nums * sizeof(char)); //malloc申请的内存没有清零
char **twoDimenArray = (char**)malloc(sizeof(char*) * nums);
int len = sizeof(twoDimenArray); //指针大小
for(int i = 0; i < nums; i++)
{
twoDimenArray[i] = (char*)malloc(sizeof(char) * 101);
}
for(int i = 0; i < nums; i++)
{
scanf("%s",twoDimenArray[i]);
}
getTwoDimenWordByDict(twoDimenArray, nums);
}
//这个题目还有几个知识点，包括:①数组传参之后，在函数中修改形参，实参也发生变化（可能和数组是传地址有关？）。
//②二维数组堆申请 ③ strcpy/memcpy ④ strcpy
//memcpy目的内存大小会不会溢出
}
//过了一段时间自己写一遍并验证 ok
void twoDimenArray()
{
//array[3][4];
int row = 3;
int column = 4;
int charactor = 65; //[97 a] [65 A]
char **p = (char**)malloc(sizeof(char*) * row);
for(int i = 0; i < row; i++)
{
p[i] = (char*)malloc(sizeof(char) * column);
}
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
p[i][j] = charactor++;
}
}
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
printf("%c ",p[i][j]);
}
}
getchar();
int charactorUpper = 97;
// char (*ptr)[column] = ( char(*)[column] )malloc(sizeof(sizeof(char) * row * column)); //x
char (*ptr)[column] = ( char(*)[column] )malloc(sizeof(sizeof(char) * row * column));
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
ptr[i][j] = charactorUpper++;
}
}
for(int i = 0; i < 3; i++)
{
for(int j = 0; j < 4; j++)
{
printf("%c ",ptr[i][j]);
}
}
}
#define func(A) A++;\
A *= 10;
#define BB 3
# define f(x) (x*x)
int defineTest()
{
int a = 10;
int b = 20;
int c = 30;
int e = -1;
unsigned f = 3;
if(a > 10)
func(a);
if(b >= 20)
func(b); //210
if(c > 30)
{
func(c);
}
if(e > 2)
{
printf("e > 2\n");
}
if(e > f) //整型提升了
{
printf("e > f\n");
}
printf("BB:%d\n",BB); //3
printf("a=%d,b=%d,c=%d\r\n",a,b,c); // 10 20 30
float d = 100;
printf("A=%f\n",d); //100.0 //100.000000默认6位小数？
printf("A=%f\n",100); //100.0 //100.000000默认6位小数？
printf("A=%f\n",(float)100);//100.0 //100.000000默认6位小数？
printf("BB:%f\n",BB); //3.0 //ERROR
int i1=f(8)/f(4) ;
int i2=f(4+4)/f(2+2) ;
printf("%d, %d\n",i1,i2);
getchar();
return 0;
}
int DIV(int x, int y, int m )
{
int n1,n2;
n1 = x*y;
n2 = n1/m;
return n2;
}
int TEST2( )
{
int a=100,b=3,c=60,d=0;
d = DIV(a,b,c);
printf("%d",d);
getchar();
}
void GetMemory(char **ppcChar, int iLength)
{
if(NULL == ppcChar)
{
return;
}
*ppcChar = (char *)malloc(iLength);
return;
}
void GetMemory2(char *ppcChar, int iLength)
{
if(NULL == ppcChar)
{
return;
}
ppcChar = (char *)malloc(iLength);
return;
}
void getMemoryMain()
{
char *szStr = NULL;
//GetMemory(&szStr, 100);
GetMemory2(szStr, 100);
if(NULL != szStr)
{
printf("NULL != szStr\n");
strcpy(szStr, "helloGetMemoryMain");
printf(szStr);
}
else
{
printf("NULL == szStr");
}
getchar();
return;
}
unsigned char g_Variable = 12;
void GetGlobalAddr(unsigned char *p)
{
p = &g_Variable;
}
void ptr_function()
{
unsigned char *temp = NULL;
GetGlobalAddr(temp);
printf("\r\n Got global variable value = %u", *temp);
getchar();
return;
}
void GetGlobalAddr2(unsigned char **p)
{
*p = &g_Variable;
}
void ptr_function2()
{
unsigned char *temp = NULL;
GetGlobalAddr2(&temp); //传一个指针进入函数，可以在函数里读取数据，但是想往指针指向的内存写数据，需要传二级指针
printf("\r\n Got global variable value = %u", (*temp));
getchar();
return;
}
char *VOS_strncpy(char *pcDest, const char *szSrc, unsigned long ulLength)
{
char *pcPoint = pcDest;
if(( NULL == szSrc ) || ( NULL == pcDest ) )
{
return NULL;
}
while(ulLength && (*pcPoint = *szSrc))/*这里采用了在判断语句中赋值的方式(*pcPoint = *szSrc)，建议尽量不使用*/
{
pcPoint++;
szSrc++;
ulLength--;
}
if(!ulLength)
{
*pcPoint = '\0';
}
return pcDest;
}
char *strcatTest(char *s1, const char *s2) //函数返回类型为指针，形参为两个指针（为字符串数组的数组名，相当于指向数组第一个元素的指针）
{
char *tmp = s1; //将指针tmp赋值为s1指针，也就是指向字符串数组*s1第一个字符的指针
while(*s1)
s1++; // 指针s1从指向字符串数组第一个元素逐渐递增到指向字符串数组末尾的null的空指针。
while(*s1++ = *s2++) // 从指针s1当前的位置开始，字符串数组s2的元素一次复制给字符串s1，直到s2指针指向null。
;
return tmp; // 返回指针tmp，指向字符串数组*s1第一个元素的指针 //这个地方返回的局部指针为什么没有问题,2023年5月25日15:41:50 返回的是指针，但是指向的内存不会释放
}
void AddFunc (unsigned int a, unsigned int b, unsigned int * c)
{
*c = a + b;
}
void GetMemoryPtr(char **ppcChar, int iLength)
{
if(NULL == ppcChar)
{
return;
}
*ppcChar = (char *)malloc(iLength);
return;
}
void strncpy_funtion(void)
{
char szStrBuf[ ] = "1234567890";
char szStrBuf1[ ] = "1234567890";
strncpy(szStrBuf, "ABCD", strlen("ABCD")); //ABCD567890
VOS_strncpy(szStrBuf1, "ABCD", strlen("ABCD")); //ABCD VOS_strncpy在末尾加\0
printf("Str1 = %s\nStr2 = %s\n", szStrBuf, szStrBuf1);
int a = 4;
float m = 3.14159;
printf("%.*f\n", a, m);
printf("%.4f\n", m);
int b = atoi("50Y");
printf("%d\n",b);
char sFront[10] = "HelloY";
char sRear[10] = "WorldY";
char *sF = sFront;
char *sR = &sRear[2];
strcat(sF, sR);
printf("%s\n", sF); //预期 HelloYrldY
char s[10] = "HelloY";
char *s1 = s;
char *s2 = &s[2];
//strcat(s1, s2);
printf("%s\n", s1); //预期 HelloYlloY 报错 strcat没办法处理重叠内存 memcpy也无法处理重叠内容（可能会出错） memcpy_s可以避免因为des内存长度小于src而出现内存异常的问题
char sMemmove[10] = "HelloY";
char *s1Memmove = sMemmove;
char *s2Memmove = &sMemmove[2];
memmove(s1Memmove, s2Memmove, 5); //将s2Memmove指向字符串拷贝到s1Memmove指向内存中
printf("%s\n", s1Memmove); //预期 HelloYlloY
int x = 5;
do {
x--;
printf("#");
} while(3<=x && x<=4);
// do {
// x--;
// printf("#");
// } while(3<=x<=4); //这是关键一句：无论x为何值，逻辑表达式3<=x只有1、0两个值，无论1或0都<4，所以3<=x<=4永远为“真”，所以是死循环
char str1[] = "gfr\0yfgat";
char str2[] = "thisis";
char *p = NULL;
p = strcatTest(str1, str2); //gfrthisis
printf("%s\n", p);
char NOPASS[]="1234";
int len1 = sizeof(NOPASS); //4
int len2 = sizeof("1234"); //4
printf("len1:%d, len2:%d\n", len1, len2); //ERROR
char st ='\092';
printf("%c\n", st); //2?
char str[] = "\\\0";
int len3 = sizeof(str); //3
int len4 = strlen(str); //1
printf("len3:%d, len4:%d\n", len3, len4);
char strCopy[] = "\\\0";
int len5 = sizeof(strCopy); //3
int len6 = strlen(strCopy); // 【"\\\\0" len=3】 【"aaa\0" len=3】 【"\\\0" len=1】
printf("len5:%d, len6:%d\n", len5, len6);
int len7 = sizeof(*strCopy); //3 ERROR
printf("len7:%d, *strCopy:%c\n", len7, *strCopy); //3,\
unsigned char e = 200;
unsigned char f = 100;
unsigned char g = 0;
AddFunc((unsigned int)e,(unsigned int)f,(unsigned int *)&g);
printf("g=%d ",g); //44
char *szStr = NULL;
GetMemoryPtr(&szStr, 100);
if(NULL != szStr)
{
strcpy(szStr, "hello");
printf(szStr);
}
free(szStr);
szStr = NULL;
getchar();
}
void diliverTwoDirectionArray(int array[4][5], int line, int row)
{
for(int i = 0; i < line; i++)
{
for(int j = 0; i < row; j++)
{
array[i][j] += 1;
}
}
}
void diliverTwoDirectionArray2(int array[4][5], int line, int row) //这边可以更改数组的内容，可以理解为穿的是地址，更改的是地址里的内容
{
for(int i = 0; i < line; i++)
{
for(int j = 0; j < row; j++)
{
array[i][j] += 1;
}
}
}
void printTwoDirectionArrayWay1(int array[4][5], int line, int row)
{
for(int i = 0; i <4; i++)
{
for(int j = 0; j < 5; j++)
{
//printf("%d ",array[i][j]);
printf("%d ", *(*(array + i) + j));
if((j + 1) % 5 == 0)
{
printf("\n");
}
}
}
}
void printTwoDirectionArrayWay2(int (*array)[5], int line, int row)
{
for(int i = 0; i <4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%d ",array[i][j]); //不是malloc出的二维数组也可以按照array[i][j]访问
//printf("%d ", *(*(array + i) + j));
if((j + 1) % 5 == 0)
{
printf("\n");
}
}
}
}
void printTwoDirectionArrayWay3(int **array, int line, int row)
{
for(int i = 0; i <4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%d ",array[i][j]); //不是malloc出的数组可以这样访问数据
//printf("%d ", *(*(array + i) + j));
if((j + 1) % 5 == 0)
{
printf("\n");
}
}
}
}
void twoDirectionArray()
{
int num = 0;
//scanf("%d",&num);
num = 4;
int array2[num][5]= {0}; //这边在牛客编译器上是报错的，报 error: variable-sized object may not be initialized //数组[]里面只能是常量或者常量式
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
array2[i][j] = (i+1)*(j+1);
printf("%d ", array2[i][j]);
if((j + 1) % 5 == 0)
{
printf("\n");
}
}
}
int **array = (int**)malloc(sizeof(int*) * 4);
// *array = (int*)malloc(sizeof(int) * 5);
for(int i = 0; i < 4; i++)
{
array[i] = (int*)malloc(sizeof(int) * 5);
}
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
array[i][j] = (i+1)*(j+1);
printf("%d ", array[i][j]);
if((j + 1) % 5 == 0)
{
printf("\n");
}
}
}
printf("use * jiexi two direction array\n");
for(int i = 0; i < 4; i++)
{
for(int j = 0; j < 5; j++)
{
printf("%d ", array[i][j]);
printf("%d ", *(array[i] + j));
printf("%d ", *(*(array + i) + j)); //array[i] = *(array + i)
}
}
printf("finish\n");
int arrayTest[4][5] = {{1,2,3,4,5}, {11,12,13,14,15}, {21,22,23,24,25}, {31,32,33,34,35}};
diliverTwoDirectionArray2(arrayTest, 4, 5);
//printTwoDirectionArray(arrayTest,4,5);
//printTwoDirectionArrayWay2(arrayTest,4,5); //不是经过malloc生成的二维数组，可以直接按照方法一(array[x][y])传参，在函数体内可以以array[i][j]访问
printTwoDirectionArrayWay3(array, 4, 5);
printf("ok");
getchar();
}
void test7()
{
char a[5] = "1234";
int* ptr = (int*)a;
printf("ptr:%x\r\n", *ptr); //0x31323334 ERROR 正确答案 0x34333231,虽然栈是向下生长的，但是数组是申请到一块内存，从低地址向高地址存储的。内存中分布：31 32 33 34 \0，根据小端原则，所以是0x34333231。另外发现好像变量和数组内存不连续
int test1 = 0x12345678;
char ch[][5] = {"4934","8254"};// char *p[2];
char *p[2];
int i,j,s = 0;
for(int i = 0; i < 2; i++)
p[i] = ch[i];
for(i = 0; i < 2; i++)
for(j = 0; p[i][j] > '\0'&&p[i][j] <= '9'; j += 2)
s = 10 * s + p[i][j] - '0';
printf("%d\n",s);
}
void test8()
{
unsigned int index2 = -1;
printf("%u\n",index2); //4294967295
int index = -1;
for(;index < sizeof(int); index++)
{
printf("i:%d\n",index); //-10123 //ERROR
}
intAndUnsignedOperation();
int x = -5, y = sizeof(int); //sizeof返回值无符号，x强制转换成无符号
if(x < sizeof(int))
{
printf("x<y\n");
}
else
{
printf("x>y\n"); //打印x>y
}
int cal = x + sizeof(int); //x补码 1111 1111 1111 1111 1111 1111 1111 1011 , +4即加100, 变成1111 1111 1111 1111 1111 1111 1111 1111，有符号即-1
printf("cal:%d\r\n",cal); // -1
cout << x + sizeof(int) << endl;// -1 x REEOR
printf("cal:%d\r\n",cal); // -1
printf("cal:%u\r\n",cal); // 即1111 1111 1111 1111 1111 1111 1111 1111转换成无符号4,294,967,295
printf("x:%d\r\n",x); // -5
printf("x:%u\r\n",x); // 即1111 1111 1111 1111 1111 1111 1111 1011转换成无符号4,294,967,291
// int m = 4;
// int n = 6;
// int k = m++-+-+---n;
// printf("k=%d",k);
char* hello = "Hello";
char a1234[5] = "1234";
int *aptr = (int*)a1234;
printf("ptr:%x\r\n",*aptr); //0x34333231
int test = 0xaabbccdd;
int b = sizeof(int);
string str = "hello world";
char chara[] = "hello world";
int c = sizeof(str);
printf("sizeof(str):%d\n",c); //12 ERROR
printf("sizeof(chara):%d\n",sizeof(chara)); //12
// char array[2] = {};
// array = (char)test;
TEST mytest;
memcpy(&mytest,"HelloWorld",sizeof(mytest));
cout<<mytest.a<<endl; //9
cout<<mytest.b<<endl; //6
cout<<mytest.c<<endl; //2
//ERROR
int sample = 0b11111111111111111111111111111111;
cout<<sample<<endl; // -1
using std::cout;
using std::endl;
}
int main()
{
int num = 5;
int num2 = 5;
int array[num] = {0};
int num3 = 0x12;
printf("%p, %p, %p, %p\n",&num, &num2, array, &num3);
// twoDirectionArray(); //二维数组相关
// strncpy_funtion();
// ptr_function2();
// getMemoryMain();
// TEST2();
// defineTest();
// twoDimenArray();
// testTwoDimensionalArrayBack();
// testTwoDimensionalArray();
// test1202();
// charTest();
// DefineTest();
// testDigui2(); //可能是生兔子的编程代码
// testDigui(); //不是递归，应该是迭代吧
// test11();
// testduiqi();
// testAddress();
// niukePractise();
// memoryTest();
// ptrTest();
// test6();
// test7();
// FILE *fp;
// if( (fp = fopen("d:\\world.txt","w")) == NULL)
// {
// printf("\nerror on open c: \\hello file!");
// }
//
// int charator = 22;
//
// for(charator; charator < 100; charator++)
// {
// fputc(charator,fp);
// }
//
// fputc(charator,fp);
//
// int readBuff[50] = {};
//
// fread(readBuff, 10, 5, fp);
//
// fclose(fp);
//
// getchar();
// exit(1);
// test8();
// Brass Piggy("Porcelot Pigg", 381299, 4000.00);
// BrassPlus Hoggy("Horatio Hogg", 382288, 3000.00);
// Piggy.ViewAcct();
// cout << endl;
// Hoggy.ViewAcct();
// cout << endl;
// cout << "Depositing $1000 into the Hogg Account:\n";
// Hoggy.Deposit(1000.00);
// cout << "New balance: $" << Hoggy.Balance() << endl;
// cout << "Withdrawing $4200 from the Pigg Account:\n";
// Piggy.Withdraw(4200.00);
// cout << "Pigg account balance: $" << Piggy.Balance() << endl;
// cout << "Withdrawing $4200 from the Hogg Account:\n";
// Hoggy.Withdraw(4200.00);
// Hoggy.ViewAcct();
// std::cin.get();
// return 0;
cout << "bye, Hello world!" << endl;
return 0;
}
void intAndUnsignedOperation()
{
char a = -20;
unsigned test = a;
unsigned int b = 10;
int x = -10;
unsigned int y = 20;
if(x + y > 0)
{
cout << "start" << endl;
cout << x+y << endl; //2147483678 × //10
printf(">0,%d",x+y); //10
}
else if(x + y < 0)
{
printf("<0,%d",x+y);
}
else if(x + y == 0)
{
printf("=0,%d",x+y);
}
if(a > b)
{
cout << "a > b a/b=" << a/b << endl; //a>b 15 × a>b 214748364 x
}
else
{
cout << "a < b a/b=" << a/b << endl;
}
cout << "a+b=" << a + b << endl;//此时输出：a > b a/b=429496727 a+b=4294967286 x
//2023年5月25日17:28:01 a > b a/b=429496727 a+b=-10 √
getchar();
}
多回顾练习哈。
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
扫一扫
3489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
