结构体对象使用malloc初始化时候有办法直接对结构体变量赋值吗

结构体对象使用malloc初始化时候有办法直接对结构体变量赋值吗?

c

5个回答

如果是C++的结构体,可以在构造函数中赋值,比如
struct data
{
int a;
data()
{
a = 1;
}
};

lx624909677
lx624909677 不好意思,这个是new的时候才能好用的方法。malloc的话必须要手动初始化,建议使用new
大约 5 年之前 回复

没让你这么干,就老实实的,该怎么赋值就怎么赋值

你动态分配了结构体变量无非是,后面的工作需要对它进行赋值,以及各种运算。
那么,你所说malloc初始化直接赋值。是指什么样的情况的,难道是像c++中的
(构造函数)。事实上c++的构造函数在使用前你也需要用

className mycClass=new className

使用new分配内存的

#include <iostream>
using namespace std;
class className
{
    public:
    int x;
    int y;
    private:
    int a;
    int b;
};
int main(void)
{
    className * myClass=new className;
    myClass->x=1;
    myClass->y=2;
    cout<<myClass->x<<endl;
    cout<<myClass->y<<endl;
    return 0;
}

而在c里面你使用malloc分配了内存空间,你后面无非是通过指针去访问它!
怎么,感觉你像是在问,malloc分配内存后,能否自动初始化(而不是初始化malloc,后赋值)
希望能帮到你!

我们常见的是直接把结构全部初始化为空,用memset函数来实现,你是要初始化成一些内容的话,有个用法不知道是不是你想要的:
struct ST_Name
{
int iCnt;
char szTemp[128];
...
}
stTest=
{
123,
"asdfgh",
...
}

你用calloc(1,size)吧,可以初始化为0

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
结构体指针初始化问题
定义一个队列结构体,想用init方法初始化一个该结构体的指针,testQueue1和testQueue2两种方法都有问题。Queue内部的front和rear指针无法初始化。 但如果是在主程序或者testQueue函数中用malloc初始化,却是可以的。 main程序如下: #include "Queue.h" void testQueue1(); void testQueue2(); void testQueue3(); int main() { printf("\n"); testQueue1(); testQueue2(); testQueue3(); return 0; } void testQueue1() { Queue *q; InitQueue(q); printf("\n"); } void testQueue2() { Queue *q=InitQueue_H(); } void testQueue3() { Queue *q; q=malloc(sizeof(Queue)); q->qfront=malloc(sizeof(QNode)); } 头文件: #include <stdio.h> #include <stdlib.h> //定义数据结构 typedef int DATA; typedef struct _qnode; typedef struct _qnode { DATA data; struct _qnode *next; }QNode; //本定义中,qfront和qrear作为头尾指针,并不存储数据 typedef struct _queue { QNode *qfront; QNode *qrear; }Queue,*LinkedQueue; //初始化一个空队列,返回值1表示初始化成功,0表示初始化失败 int InitQueue(Queue *q); //初始化,返货Queue指针 Queue *InitQueue_H(); //判断是否为空 int IsQEmpty(Queue *q); 程序实现: #include "Queue.h" int InitQueue(Queue *q) { q=(Queue*)malloc(sizeof(Queue)); if(q==NULL)return 0; q->qfront=q->qrear=(QNode*)malloc(sizeof(QNode)); if(q->qfront==NULL) return 0; q->qfront->next=NULL; return 1; } Queue *InitQueue_H() { Queue *q=(Queue*)malloc(sizeof(Queue)); if(q==NULL)return NULL; q->qfront=q->qrear=(QNode*)malloc(sizeof(QNode)); if(q->qfront==NULL) return NULL; q->qfront->next=NULL; return q; } int IsQEmpty(Queue *q) { if(q==NULL||q->qfront==NULL||q->qrear==NULL) return; return q->qfront==q->qrear; }
关于结构体指针malloc不够的问题,求教!
定义了一个结构体类型: typedef struct _tag_str{ char * first; short second; }str ,*pstr; 然后再定义一个结构体 typedef struct _tag_str1{ pstr first; float second; }str1,*pstr1; 定义一个变量 pstr1 strr; 在对strr初始化:strr=(pstr1)malloc(sizeof(str1)), 这样其实malloc的空间大小只是一个 float的大小和一个指针变量的大小,并不是两个结构体合起来的大小,这时我为了初始化 strr->first这个结构体指针 做这样的操作:strr->first=(pstr)malloc(sizeof(str));又开 辟一个空间,现在的烦恼是既然strr的位于first的地方头一回空间开辟的只是一个指针的大小,那么第二回在这个地方又开辟了一个sizeof(str)大小的空间,这样做是不是超出了第一次开辟的空间,还是两个空间在内存中本来就是两个地方?假如把第二个结构体中的第一个变量换成str first就不存在这样的疑问了,因为第一次malloc的时候一次把空间申请够了。
结构体构成的栈初始化报错问题
char *str;似乎把这个写进结构体然后调用malloc()就报错了,各位有遇到过吗?是不是这样啊?
数据结构中关于单链表的初始化
``` typedef struct node { int a; sturct node *next; }node,*linklist; //接下来定义初始化函数,仅分配空间,不做其他操作 void initlist(linlist L2) { L2=(linklist)malloc(sizeof(node)); } // void main() { linklist L1; initlist(L1); } ``` 我的理解如下 这段代码中,L1定义为指向结构体node的一个指针,在初始状态下,L1可以理解为指向单链表头结点的指针。将L1的值作为实参传入初始化函数initlist时,即等于将头结点的地址传入初始化函数。在初始化函数中,使用指向结构体的指针L2接收头结点地址,然后使用malloc函数,为头结点分配空间。 请问,以上理解正确吗?
malloc怎么返回结构体指针数组的首地址
typedef struct student{ int id; }s ,*sp; main(){ sp p1=(sp)malloc(10*sizeof(sp)); // 假设1 sp * p2=(sp *)malloc(10*sizeof(sp)); // 假设2 } 如果我要malloc一个长度为10 的结构体指针数组的话 假设1 和假设2 哪个返回了结构体指针数组的首地址? 哪个正确呢
用freetype转换字符串成位图数据问题?
这是我的转化代码,转换出来的效果图: ![图片说明](https://img-ask.csdn.net/upload/202001/22/1579661860_266102.png) 我是转换一个字符串:HELLO,但是为什么最后成了两个,而且宽和高似乎都给成了两倍,以下是代码,请大神分析下下面的代码有问题吗?如何修改 ``` static int GetBitmap( char* szFontFile, wchar_t* swText, int ulLen, int nFontSize, int nSpace, BITMAP_S *stBitmap) { FT_Library ftLib = NULL; FT_Face ftFace = NULL; FT_Error ftError = 0; FT_Bitmap ftBitmap; FT_BitmapGlyph ftBmpGlyph; FT_Glyph ftGlyph; FT_GlyphSlot ftGlyphslot; int i, j, k, temp; int start_x = 0, start_y = 0; int nChHeight = 0, nChWidth = 0, nTextWidth = 0; size_t size = 0; unsigned char** pTextAlpha = NULL; int BgHeight = nFontSize + 5; /* 背景图形的高度,这个高度要大于字体的高度,所以是+5 */ ftError = FT_Init_FreeType(&ftLib); if (ftError) { printf("FT_Init_FreeType() Failed!\n"); ftLib = 0; return -1; } printf("========fontfile=%s\n", szFontFile); ftError = FT_New_Face(ftLib, szFontFile, 0, &ftFace); /*if (ftError == FT_Err_Unknown_File_Format) { printf("FT_New_Face() Failed! FT_Err_Unknown_File_Format\n"); return -2; } else */if (ftError) { printf("FT_New_Face() Failed %d! Other Error!\n", ftError); return -3; } pTextAlpha = (uint8_t**)malloc(sizeof(uint8_t*)*BgHeight); //分配内存,用于存储字体背景的数据 if (NULL == pTextAlpha) { printf("malloc() Failed!\n"); return -1; } for (i=0; i < BgHeight; i++) { pTextAlpha[i] = (uint8_t*)malloc(sizeof(uint8_t)*1); //为背景图的每一行分配内存 if (NULL == pTextAlpha[i]) { printf("malloc() Failed! %d\n", i); return -1; } } ftError = FT_Select_Charmap(ftFace, FT_ENCODING_UNICODE); //设置字体的编码方式 if (ftError) { printf("FT_Select_Charmap() Failed! error=%d\n", ftError); return ftError; } ftError = FT_Set_Pixel_Sizes(ftFace, 0, nFontSize); //设置字体大小 if (ftError) { printf("FT_Set_Pixel_Sizes() Failed! error=%d\n",ftError); return ftError; } uint8_t *data; ftGlyphslot = ftFace->glyph; printf("======================ulen = %d\n", ulLen); for (temp = 0; temp < ulLen; temp++) { printf("#######################swText[%d]=%04x\n", temp,swText[temp]); ftError = FT_Load_Char(ftFace, swText[temp], FT_LOAD_RENDER | FT_LOAD_NO_AUTOHINT);//提取一个字形图像 if (ftError) { printf("FT_Load_Char() Failed!, ftError=%d\n", ftError); continue; } ftError = FT_Get_Glyph(ftFace->glyph, &ftGlyph); if (ftError) { printf("FT_Get_Glyph() Failed!"); return ftError; } if (swText[temp] == L' ')//如果取得的为空格 { printf("M MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM M\n"); k = 0; nChWidth = (nFontSize - 2) / 2; nChHeight = nFontSize; nTextWidth = start_x + nChWidth; start_y = 0; for (i = 0; i < BgHeight; i++) { pTextAlpha[i] = (uint8_t*)realloc(pTextAlpha[i], sizeof(uint8_t)*nTextWidth); memset(pTextAlpha[i], 0 ,sizeof(uint8_t)*nTextWidth); for (j = start_x - nSpace; j < nTextWidth; j++) { pTextAlpha[i][j] = 0; } } for (i = 0; i < nChHeight; i++) { for (j=0; j< nChWidth; j++) { pTextAlpha[start_y+i][start_x+j] = 0; k++; } } start_x += (nChWidth + nSpace); /* 画笔向右边移动 */ } else { /* 256级灰度字形转换成位图 */ ftError = FT_Glyph_To_Bitmap(&ftGlyph, FT_RENDER_MODE_NORMAL , NULL, 1); if (ftError) { printf("FT_Glyph_To_Bitmap() Failed!\n"); } ftBmpGlyph = (FT_BitmapGlyph)ftGlyph; ftBitmap = ftBmpGlyph->bitmap; k = 0; printf("XXXXXXXXXX:nFontSize = %d, bitmap_top = %d\n", nFontSize, ftGlyphslot->bitmap_top); printf("XXXXXXXXXX:ftBitmap.rows = %d, BgHeight = %d\n", ftBitmap.rows, BgHeight); start_y = nFontSize - ftGlyphslot->bitmap_top + 2; /* 获取起点的y轴坐标 */ //start_y = nFontSize - ftBitmap.rows + 2; if(start_y < 0) { start_y = 0; } if (ftBitmap.rows > BgHeight) { nChHeight = nFontSize; } else { nChHeight = ftBitmap.rows; } if (nChHeight + start_y > BgHeight) { nChHeight = BgHeight - start_y; } nChWidth = ftBitmap.width; nTextWidth = start_x + ftBitmap.width; printf("XXXXXXXXXX:nChHeight = %d, nChWidth = %d, nTextWidth = %d\n",nChHeight, nChWidth, nTextWidth); for (i=0; i<BgHeight; i++) { pTextAlpha[i] = (uint8_t*)realloc(pTextAlpha[i], nTextWidth); for (j = start_x - nSpace; j < nTextWidth; j++) { if(j < 0) j = 0; pTextAlpha[i][j] = 0; } } for (i = 0; i < BgHeight; i++) { for (j = 0; j < nChWidth; j++) { if (i >= start_y && i < start_y + nChHeight) { pTextAlpha[i][start_x + j] = ftBitmap.buffer[k]; k++; } else { pTextAlpha[i][start_x + j] = 0; } } } start_x += (nChWidth + nSpace); FT_Done_Glyph(ftGlyph); printf("FT_Done_Glyph() Success!\n"); ftGlyph = NULL; } } FT_Done_Face(ftFace); ftFace = NULL; FT_Done_FreeType(ftLib); ftLib = NULL; stBitmap->u32Width = nTextWidth; stBitmap->u32Height = BgHeight; size = sizeof(uint8_t) * nTextWidth * BgHeight; stBitmap->pData = (uint8_t*)malloc(size); memset(stBitmap->pData, 0, size); printf("===================nTextWidth = %d\n", nTextWidth); printf("===================BgHeight = %d\n", BgHeight); printf("===================nChHeight = %d\n", nChHeight); k = 0; for (i = 0; i < BgHeight; i++) { memcpy(((char*)stBitmap->pData) + k, pTextAlpha[i], nTextWidth); k += nTextWidth; free(pTextAlpha[i]); pTextAlpha[i] = NULL; } free(pTextAlpha); pTextAlpha = NULL; return 0; } ```
请问如何用linux套接字编程来发挥万兆网卡的性能?
双线程,一个生产数据放入kfifo,一个从kfifo取出数据,通过套接字发送。最终测试出来速度只能达到400MB/S。(kfifo出队64KB数据要100us) 之后我将生产者做了更改,让它只更新队首的in指针,不做数据拷贝,此时速度能达到1000MB/S。(kfifo出队64KB数据只要10us) 我怀疑是生产者生产数据写入队列时,导致消费者所在的cpu cache失效,然后cache未命中导致速度骤降。但是不知道怎么解决这个问题。 在网上搜索答案,但是没有找到类似情况。看到有一个和我问题应该比较类似的,但是没有找到解决方法。 《请问为何tcp send第一次时很慢, 第二次时很快呢?》 https://www.oschina.net/question/2897213_2193602 ```c #include "szg_common.h" #include "szg_kfifo.h" #include "szg_socket.h" /**kfifo * 队列是将linux内核中的kfifo移到了这里来用,用malloc来替代内核中的kmalloc * 此代码(发送端)运行在NXP T4240上,系统linux,万兆网卡。 * 接收端软件运行在PC上,系统windows10,万兆网卡。 * * 1.正常出入队,kfifo总大小64M 元素大小256bytes 期望出队和期望入队都是256个元素 * 速度400MB/S 出队64k要100us send要50us * 2.注释掉kfifoin中的两行memcpy(szgKfifoCopyIn中的),让其只更新队首in指针 * 速度1000MB/S 出队64k要10us send要50us * * */ #define KFIFO_SEND_SIZE 0x10000 //64k #define FIFO_IN 0x100 //每次入队时期望入队的元素个数:256个(即256*256 = 64k) #define FIFO_OUT 0x100 //每次出队时期望出队的元素个数:256个(即256*256 = 64k) #define FIFO_E_SIZE 0x100 //元素大小:256byte #define FIFO_SIZE 0x4000000 //总大小:64Mbyte (256*256*1024个) kfifo testkFifo; void *szgTestKfifoThread(void *param) { UINT32 ret; char data_buf[KFIFO_SEND_SIZE] = {0}; while(TRUE) { ret = szgKfifoIn(&testkFifo,data_buf,FIFO_IN); if(ret == 0) { pthread_yield(); //usleep(2); } } } int kfifo_test(void) { INT32 listenFd; INT32 connectFd; INT32 ret; UINT32 clientIp; pthread_t threadId; pthread_attr_t attr; struct timeval start,end; char send_buf[KFIFO_SEND_SIZE]; memset(send_buf,1,KFIFO_SEND_SIZE); signal(SIGPIPE,SIG_IGN); /** * 初始化kfifo * 总大小 64M * 元素大小 256byes * 元素个数 256*1024个 * 出队,入队都是期望256个元素,不到256个有多少出多少,实际个数作为返回值返回 */ ret = szgKfifoAlloc(&testFifo,FIFO_SIZE/FIFO_E_SIZE,FIFO_E_SIZE); CHECK_EXIT(ret == ERROR, "fifo init err!"); /*创建线程,线程分离*/ pthread_attr_init (&attr); pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); if (0 != pthread_create(&threadId,&attr, (void *)szgTestKfifoThread,NULL)) { SZG_LOG(SZG_LOG_ERR,"Create Thread data_filter_thread Fail \n"); return ERROR; } /*服务器初始化 端口6101 发送缓存2M 接收缓存1M(2M/2)*/ listenFd = szgSockInit(NULL,6101,0x200000); CHECK_EXIT(listenFd < 0, "socket error"); while(TRUE) { printf("wait connect\n"); /*客户端ip通过&clientIp返回(其实下面没用到)*/ connectFd = szgSockAccept(listenFd,&clientIp); if (connectFd < 0) { SZG_LOG(SZG_LOG_ERR,"server Accept Failed!/n"); return 0; } while(TRUE) { //gettimeofday(&start,NULL); /*出队 256*256 */ ret = szgKfifoOut(&testkFifo,send_buf,FIFO_OUT); if(ret == 0)//没有数据 { pthread_yield(); continue; //usleep(2); } //gettimeofday(&end,NULL); //printf("kfifo time %lu us \n",(1000000*(end.tv_sec-start.tv_sec) + (end.tv_usec-start.tv_usec))); /*发送64k*/ //gettimeofday(&start,NULL); ret = szgSendData(connectFd,send_buf,ret*FIFO_E_SIZE); if(ret == ERROR) { SZG_LOG(SZG_LOG_ERR,"szgSendData data error\n"); break; } //gettimeofday(&end,NULL); //printf("send time %lu us \n",(1000000*(end.tv_sec-start.tv_sec) + (end.tv_usec-start.tv_usec))); } } return 0; } ```
使用malloc()创建一个二维数组并利用二维数组中的一行存储字符串,能办到吗
char **content = (char**)malloc(sizeof(char*) * g); for(i=0;i<g;i++) content[i]= (char*)malloc(sizeof(char) * g); printf("依次输入顶点内容\n"); for (i = 0; i < g; i++) gets_s(*(content+i)); 1>C:\Users\liuww\source\repos\Project2\源1.cpp(17,22): error C2660: “gets_s”: 函数不接受 1 个参数 怎么修改,我想要定义一个二维数组,但需要使用变量规定长度,因此用到了malloc() 利用二维数组中的一行存储一个字符串
为什么函数中的L*new报错,后面的p->next=new也不行?
![图片说明](https://img-ask.csdn.net/upload/201911/27/1574842402_80124.png) ![图片说明](https://img-ask.csdn.net/upload/201911/27/1574842280_696087.png) 为什么VS2019上报错? #include"1.h" typedef struct slist { int id; struct slist* next; }L; //创建一个节点 L* create_node(int data) { //给每个节点分配结构体一样的空间大小 L* p = (L*)malloc(sizeof(L)); if (NULL == p) { printf("malloc error!\n"); return NULL; } //由于结构体在未初始化的时候一样是脏数据,所以要清 memset(p, 0, sizeof(L)); //初始化第一个节点 p->id = data; //将节点的后继指针设置为NULL p->next = NULL; } //链表的尾插 void tail_insert(L* pH, L*new) { //获取当前的位置 L* p = pH; //如果当前位置的下一个节点不为空 while (NULL != p->next) { //移动到下一个节点 p = p->next; } //如果跳出以上循环,所以已经到了NULL的这个位置 //此时直接把新插入的节点赋值给NULL这个位置 p->next =new; }
在dev环境下,用malloc只申请了了5个char字符的空间,为什么存入的个数超过了5个
![图片说明](https://img-ask.csdn.net/upload/202001/02/1577953545_69400.png) 在dev环境下,用malloc只申请了了5个char字符的空间,为什么存入的个数超过了5个
c++结构体嵌套输入异常
如题: 要实现一个线性表的结构,但是在一开始初始化赋值时出现了问题。 ```# include <iostream> # include <string> # include <stdlib.h> using namespace std; #define INIT_SIZE 1000 #define INCREMENT 1000 typedef struct { string num; string name; float score; }student , *student_l; typedef struct { student_l Student_List; int length; int listsize; }List; int Initial_List(List &L, int n =0 ) //初始化表格,分配空间 { L.Student_List = (student_l)malloc(INIT_SIZE * sizeof(student)); if (!L.Student_List) return -1; string student_name; string student_num; float student_score = 0; /*for (int i = 0; i < n; i++) { cin >> student_num >> student_name >> student_score; L.Student_List[i].name = student_name; L.Student_List[i].num = student_num; L.Student_List[i].score = student_score; }*/ L.length = n; L.listsize = INIT_SIZE; return 0; } int main() { int student_number = 0; List student_List; cin >> student_number; Initial_List(student_List, student_number); return 0; system("pause"); } ```
请问为什么用new建立动态二维数组就会报错,用malloc就不会报错。
请问为什么用注释掉的部分建立动态二维数组就会报错,用malloc就不会报错? ``` void Matrix() { int i; //double** P_ca_x = new double* [Times]; //double** P_ca_y = new double* [Times]; //double** P_ca_z = new double* [Times]; //double** v_ca_x = new double* [Times]; //double** v_ca_y = new double* [Times]; //double** v_ca_z = new double* [Times]; //double** v_ca = new double* [Times]; P_ca_x = (double**)malloc(sizeof(double*) * Times); P_ca_y = (double**)malloc(sizeof(double*) * Times); P_ca_z = (double**)malloc(sizeof(double*) * Times); v_ca_x = (double**)malloc(sizeof(double*) * Times); v_ca_y = (double**)malloc(sizeof(double*) * Times); v_ca_z = (double**)malloc(sizeof(double*) * Times); v_ca = (double**)malloc(sizeof(double*) * Times); for (i = 0; i < Times; i++) { //P_ca_x[i] = new double[Num]; //P_ca_y[i] = new double[Num]; //P_ca_z[i] = new double[Num]; //v_ca_x[i] = new double[Num]; //v_ca_y[i] = new double[Num]; //v_ca_z[i] = new double[Num]; //v_ca[i] = new double[Num]; P_ca_x[i] = (double*)malloc(sizeof(double) * Num); P_ca_y[i] = (double*)malloc(sizeof(double) * Num); P_ca_z[i] = (double*)malloc(sizeof(double) * Num); v_ca_x[i] = (double*)malloc(sizeof(double) * Num); v_ca_y[i] = (double*)malloc(sizeof(double) * Num); v_ca_z[i] = (double*)malloc(sizeof(double) * Num); v_ca[i] = (double*)malloc(sizeof(double) * Num); } } void Delete() { int i; for (i = 0; i < Times; i++) { //delete[] P_ca_x[i]; //delete[] P_ca_y[i]; //delete[] P_ca_z[i]; //delete[] v_ca_x[i]; //delete[] v_ca_y[i]; //delete[] v_ca_z[i]; //delete[] v_ca[i]; free(P_ca_x[i]); free(P_ca_y[i]); free(P_ca_z[i]); free(v_ca_x[i]); free(v_ca_y[i]); free(v_ca_z[i]); free(v_ca[i]); } //delete[] P_ca_x; //delete[] P_ca_y; //delete[] P_ca_z; //delete[] v_ca_x; //delete[] v_ca_y; //delete[] v_ca_z; //delete[] v_ca; free(P_ca_x); free(P_ca_y); free(P_ca_z); free(v_ca_x); free(v_ca_y); free(v_ca_z); free(v_ca); } ``` 在对数组赋值时报错,用malloc则不会报错 ![图片说明](https://img-ask.csdn.net/upload/201912/13/1576227060_629527.png)
新手求助,数据结构课设的源程序,麻烦大佬们看下注释一下,搞不懂啥意思?
_#pragma once_ _#include<stdio.h>_ _#include<stdlib.h>_ _#define MAX 20_ _#define DataType char_ _ typedef struct ArcNode { int _Adjvex; //储存边所指的顶点位置 int _Weight; //储存该边的权重 int _Ee; //活动最早发生时间 int _El; //活动最晚发生时间 struct ArcNode *_NextArc; //指向下一条边的指针 }ArcNode; typedef struct VexNode { DataType _data; //顶点信息 int _InDegree; //入度 int _Flag; //拓扑排序是用来判断是否排过 int _Ve; //事件最早发生时间 int _Vl; //事件最晚发生时间 ArcNode *_FirstArc; //指向第一条依附该顶点的弧 }VexNode; typedef struct ALGraph { VexNode *_AdjList; //邻接表 int _VexNum; //结点数目 int _ArcNum; //边的数目 }ALGraph; int menu_select() { int i; do { system("cls"); printf("\t\t ╭——————————■□■□—————╮\n"); printf("\t\t│ 数 据 结 构 课 程 设 计 │\n"); printf("\t\t╰———■□■□————————————╯\n"); printf("\t\t ┌————————————————┐\n"); printf("\t\t │ 1. 用邻接表存储有向图 │\n"); printf("\t\t │ │\n"); printf("\t\t │ 2. 显 示 邻 接 表 │\n"); printf("\t\t │ │\n"); printf("\t\t │ 3. 拓 扑 排 序 │\n"); printf("\t\t │ │\n"); printf("\t\t │ 4. 逆 拓 扑 排 序 │\n"); printf("\t\t │ │\n"); printf("\t\t │ 5. 关 键 活 动 │\n"); printf("\t\t │ │\n"); printf("\t\t │ 0.退出 │\n"); printf("\t\t └————————————————┘\n"); printf("\t\t请选择(0-5):"); scanf("%d", &i); } while (i < 0 || i>5); return i; } void ClearStdin() { char ch; while ((ch = getchar()) != '\n' && ch != EOF); } int IfHaveThisVex(ALGraph* graph, DataType data) { //判断该顶点是否在_AdjList(Vex数组)中 //存在返回所在位置下标,不存在返回-1 for (int i = 0; i < graph->_VexNum; ++i) { if (graph->_AdjList[i]._data == data) { return i; } } return -1; } void CreatAdjList(ALGraph* graph) { int Weight; int FirstIndex, SecondIndex; //定义两个index存放边的两个顶点在数组中的下标 DataType FirstVex, SecondVex; //定义一个边的两个顶点值,用于接收用户输入的边的两个顶点信息 for (int i = 0; i < graph->_VexNum; ++i) { ClearStdin(); //清空输入缓冲区 //对已经malloc出来的每个顶点初始化 printf("请输入第%d个顶点的信息(例如顶点名为A,则输入A):", i + 1); scanf("%c", &(graph->_AdjList[i]._data)); graph->_AdjList[i]._Flag = 0; graph->_AdjList[i]._Ve = 0; graph->_AdjList[i]._Vl = INT_MAX; graph->_AdjList[i]._InDegree = 0; graph->_AdjList[i]._FirstArc = NULL; } system("cls"); for (int i = 0; i < graph->_ArcNum; ++i) { ClearStdin(); //清空输入缓冲区 printf("请输入有向图中第%d边的两个顶点以及权重(例:A->B权重5 则输入A B 5):", i + 1); scanf("%c %c %d", &FirstVex, &SecondVex, &Weight); FirstIndex = IfHaveThisVex(graph, FirstVex); SecondIndex = IfHaveThisVex(graph, SecondVex); if (FirstIndex == -1 || SecondIndex == -1) { i = i - 1; printf("输入顶点信息错误,请重新输入!!\n"); continue; } ArcNode * NewArc = (ArcNode*)malloc(sizeof(ArcNode)); NewArc->_Adjvex = SecondIndex; NewArc->_Weight = Weight; NewArc->_NextArc = graph->_AdjList[FirstIndex]._FirstArc; graph->_AdjList[FirstIndex]._FirstArc = NewArc; graph->_AdjList[SecondIndex]._InDegree++; } } void ALGraphInit(ALGraph* graph) { system("cls"); printf("请输入有向图顶点的个数:"); scanf("%d", &(graph->_VexNum)); printf("请输入有向图边的条数:"); scanf("%d", &(graph->_ArcNum)); graph->_AdjList = (VexNode*)malloc(sizeof(VexNode)*(graph->_VexNum)); CreatAdjList(graph); } void PrintfVexNode(VexNode *node) { ArcNode* cur = node->_FirstArc; printf("[%c]", node->_data); if (cur) { printf("-->[ %d ]", cur->_Adjvex); cur = cur->_NextArc; } while (cur) { printf("-->[ %d ]", cur->_Adjvex); cur = cur->_NextArc; } printf("-->[NULL]\n"); } void PrintfAdjList(ALGraph* graph) { system("cls"); for (int i = 0; i < graph->_VexNum; ++i) { printf("%d ", i); PrintfVexNode(&(graph->_AdjList[i])); } system("pause"); } void TopologicalSorting(ALGraph* graph,int *arr) { system("cls"); if (arr[MAX - 1] == 1) { printf("该图已经进行过拓扑排序!\n"); system("pause"); return; } int count = 0; int flag = 1; while (flag) { flag = 0; for (int i = 0; i < graph->_VexNum; ++i) { if (graph->_AdjList[i]._InDegree == 0 && graph->_AdjList[i]._Flag == 0) { flag = 1; graph->_AdjList[i]._Flag = 1; arr[count] = i; count++; ArcNode* cur = graph->_AdjList[i]._FirstArc; while (cur) { if (cur->_Weight + graph->_AdjList[i]._Ve > graph->_AdjList[cur->_Adjvex]._Ve) { graph->_AdjList[cur->_Adjvex]._Ve = cur->_Weight + graph->_AdjList[i]._Ve; } graph->_AdjList[cur->_Adjvex]._InDegree--; cur = cur->_NextArc; } break; } } } for (int i = 0; i < count; ++i) { printf("[%c][Ve: %d]\n", graph->_AdjList[arr[i]]._data, graph->_AdjList[arr[i]]._Ve); } printf("[NULL]\n"); if (count < graph->_VexNum) { printf("事件输出数量小于总数量,图中带环!!\n"); } else { arr[MAX - 1] = 1; printf("事件输出数量等于总数量,图中不带环!!\n"); } system("pause"); } void RTopologicalSorting(ALGraph* graph, int *arr) { system("cls"); if (arr[MAX - 1] == 0) { printf("请确保次图不带环并且已进行过拓扑排序后再试!\n"); system("pause"); return; } graph->_AdjList[arr[graph->_VexNum - 1]]._Vl = graph->_AdjList[arr[graph->_VexNum - 1]]._Ve; for (int i = graph->_VexNum - 2; i >= 0; --i) { ArcNode *cur = graph->_AdjList[arr[i]]._FirstArc; while (cur) { if ((graph->_AdjList[cur->_Adjvex]._Vl) - (cur->_Weight) < graph->_AdjList[arr[i]]._Vl) { graph->_AdjList[arr[i]]._Vl = (graph->_AdjList[cur->_Adjvex]._Vl) - (cur->_Weight); } cur = cur->_NextArc; } } for (int i = graph->_VexNum - 1; i >= 0; --i) { printf("[%c][Ve: %d]\n", graph->_AdjList[arr[i]]._data, graph->_AdjList[arr[i]]._Vl); } arr[MAX - 2] = 1; //printf("[NULL]"); system("pause"); } void KeyActivites(ALGraph* graph, int *arr) { system("cls"); if (arr[MAX - 2] == 0 || arr[MAX - 1] == 0) { printf("请确保该图进行过拓扑排序及逆拓扑排序后再试\n"); system("pause"); return; } for (int i = 0; i < graph->_VexNum; ++i) { ArcNode* cur = graph->_AdjList[arr[i]]._FirstArc; while (cur) { cur->_Ee = graph->_AdjList[arr[i]]._Ve; cur->_El = graph->_AdjList[cur->_Adjvex]._Vl; printf("活动[%c]-->[%c]的最早发生时间:%d 最晚发生时间:%d\n", graph->_AdjList[arr[i]]._data, graph->_AdjList[cur->_Adjvex]._data, cur->_Ee, cur->_El); cur = cur->_NextArc; } } printf("-------------------------------------------\n"); printf("关键路径如下:\n"); for (int i = 0; i < graph->_VexNum; ++i) { ArcNode* cur = graph->_AdjList[arr[i]]._FirstArc; while (cur) { //顶点的最早发生时间和最晚发生时间相等即在关键路径上 if (graph->_AdjList[arr[i]]._Ve == graph->_AdjList[arr[i]]._Vl &&graph->_AdjList[cur->_Adjvex]._Ve == graph->_AdjList[cur->_Adjvex]._Vl) { printf("活动[%c]-->[%c] 长度:%d\n", graph->_AdjList[arr[i]]._data, graph->_AdjList[cur->_Adjvex]._data, cur->_Weight); } cur = cur->_NextArc; } } system("pause"); } int main() { ALGraph G; int arr[MAX]; //存放拓扑排序顺序 arr[MAX - 1] = 0; //标志位来判断是否进行过拓扑排序 arr[MAX - 2] = 0; //标志位来判断是否进行过逆拓扑排序 while (1) { switch (menu_select()) { case 1: ALGraphInit(&G); break; case 2: PrintfAdjList(&G); break; case 3: TopologicalSorting(&G,arr); break; case 4: RTopologicalSorting(&G, arr); break; case 5: KeyActivites(&G, arr); break; case 0: printf("\t\t系统退出!!\n"); system("pause"); exit(0); } } } ``` ```
C语言中malloc动态分配空间的使用
求解答,我看不出来怎么解决,谢谢! ``` #include<stdio.h> #include<stdlib.h> int main(void) { int count, *array; if ((array(int *)malloc (10 * sizeof(int))) == NULL) { printf("can not success!\n"); exit(1); } for (count = 0; count < 10; count++) array[count] = count; for (count = 0; count < 10; count++) printf("%2d ", array[count]); return 0; } ```
malloc(): memory corruption (fast): C++ opencv编写出错
好象是亮度调整那里出错了,可是不知道怎么改 ``` int main(){ Mat re_src_image; Mat src_image = imread("/home/zn/桌面/13740146-f01b848b12b93174.png",1); if(! src_image.data){ cout << "Couldn't find the image!\n"; return false; } else { resize(src_image, re_src_image, Size(640, 480)); vector<Mat> channels; split(re_src_image, channels); re_src_image = channels.at(2); } //亮度调整 int ContrastValue = 100; int BrightValue = 0; Mat light_image = Mat::zeros(re_src_image.size(), re_src_image.type()); for (int y = 0; y < re_src_image.rows; y++) { for (int x = 0; x < re_src_image.cols; x++) { for (int c = 0; c < 3; c++){ light_image.at<Vec3b>(y, x)[c] = (ContrastValue*0.01)*(re_src_image.at<Vec3b>(y, x)[c]) + BrightValue; } } } imshow("a",re_src_image); while(1){ if(waitKey(0)==27) break; } return 0; } ```
数据结构,关于内存初始化分配
在写循环队列时,经测试,在“Q->pBase=(int *)malloc(maxsize*sizeof(int));”该条语句执行时出错,以下为部分代码,请各位大大们救救小白.. ``` typedef struct queue { int *pBase; int front; //指向队列第一个元素 int rear; //指向队列最后一个元素的下一个元素 int maxsize; //循环队列的最大存储空间 }Queue,*PQueue; void InitQueue(PQueue Q,int maxsize); //初始化队列 void QueueTraverse(PQueue Q); //队列遍历 int DestroyQueue(PQueue Q); //摧毁队列Q int ClearQueue(PQueue Q); //清空队列Q int QueueLength(PQueue Q); //返回队列Q的长度 int GetHead(PQueue Q,int *e); //返回队列Q的队头元素 int QueueFull(PQueue Q); //判断队列是否为满 int QueueEmpty(PQueue Q); //判断队列是否为空 int Enqueue(PQueue Q, int e); //插入元素e为Q的队尾元素 int Dequeue(PQueue Q, int *e); //删除Q的队头元素,并用e返回其值 void InitQueue(PQueue Q,int maxsize) { Q->pBase=(int *)malloc(maxsize*sizeof(int)); printf("malloc_OK\n"); if(NULL==Q->pBase) { printf("Memory allocation failure"); exit(-1); //退出程序 } Q->front=0; //初始化参数 Q->rear=0; Q->maxsize=maxsize; } …………………… int main() { PQueue Open; InitQueue(Open,10); printf("OK\n"); Enqueue(Open,12); QueueTraverse(Open); } ```
在linux下运行c语言代码出现这种段错误的原因。
## 1.当将lockId代码块放在后面时会出现段错误。 ``` #include <stdio.h> #include <stdlib.h> #include <string.h> //#include "packag_server.h" #define DATA_LEN 500 char *Login_post_reply(char *msg) { char *productId = malloc(DATA_LEN); char *featureId = malloc(DATA_LEN); char *lockId = malloc(DATA_LEN); char *t = malloc(DATA_LEN); productId = strstr(msg, "productId"); productId += 11; t = strstr(productId, ","); *t = '\0'; printf("productId = %s\n",productId); featureId = strstr(msg, "featureId"); featureId += 11; t = strstr(featureId, ","); *t = '\0'; printf("featureId = %s\n",featureId); lockId = strstr(msg, "lockId"); lockId += 9; t = strstr(lockId, "\""); *t = '\0'; printf("lockId = %s\n",lockId); printf("productId = %s featureId = %s lockId = %s\n",productId, featureId, lockId); /* if(qp(productId, featureId, lockId)) { } */ } int main() { char data[] = "{ \n" " id\": 12345,\n" " featureId\": 0,\n" " productId\": 0,\n" " lockId\":\"123456\",\n" " sign\":\"7f383431123232\",\n" " method\":\n\"Login_post\"\n" "}\n"; Login_post_reply(data); //printf("data = %s\n",data); return 0; } ``` 编译后执行结果如下: ![图片说明](https://img-ask.csdn.net/upload/202001/13/1578877394_881944.png) ## 2.将lockId代码块放在首位能够正常执行。 ``` #include <stdio.h> #include <stdlib.h> #include <string.h> //#include "packag_server.h" #define DATA_LEN 500 char *Login_post_reply(char *msg) { char *productId = malloc(DATA_LEN); char *featureId = malloc(DATA_LEN); char *lockId = malloc(DATA_LEN); char *t = malloc(DATA_LEN); lockId = strstr(msg, "lockId"); lockId += 9; t = strstr(lockId, "\""); *t = '\0'; printf("lockId = %s\n",lockId); productId = strstr(msg, "productId"); productId += 11; t = strstr(productId, ","); *t = '\0'; printf("productId = %s\n",productId); featureId = strstr(msg, "featureId"); featureId += 11; t = strstr(featureId, ","); *t = '\0'; printf("featureId = %s\n",featureId); printf("productId = %s featureId = %s lockId = %s\n",productId, featureId, lockId); /* if(qp(productId, featureId, lockId)) { } */ } int main() { char data[] = "{ \n" " id\": 12345,\n" " featureId\": 0,\n" " productId\": 0,\n" " lockId\":\"123456\",\n" " sign\":\"7f383431123232\",\n" " method\":\n\"Login_post\"\n" "}\n"; Login_post_reply(data); //printf("data = %s\n",data); return 0; } ``` 编译后执行结果如下: ![图片说明](https://img-ask.csdn.net/upload/202001/13/1578877584_378874.png) 这种段错误的原因是什么?
C语言用malloc有数量限制吗?
``` #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #include<time.h> //1.定义一个结构体 struct dicts { char * word; //存放单词 char * trans; //存放单词的意思 }; int main(void) { int MAXNUM = 0; char arr[1024] = { 0 }; int i = 0; struct dicts * dic; struct dicts * dic1; dic = (struct dicts *) malloc(sizeof(struct dicts)*MAXNUM); dic1 = (struct dicts *) malloc(sizeof(struct dicts)); //打开一个单词文件 FILE * fp = fopen("D:\\dict.txt", "r"); if (!fp) { printf("文件打开失败!"); return -1; } //判断dict.txt中有多少个单词 while (!feof(fp)) { fgets(arr, 1024, fp); i++; } MAXNUM = i / 2; printf("%d\n", MAXNUM); //将文件光标从新定位到开头 rewind(fp); //将所有的单词都读取到dic结构体中 i = 0; while (!feof(fp)) { printf("%d\n", i); //将单词放到dic[i].word中 memset(arr, 0, 1024); fgets(arr, 1024, fp); dic[i].word = (char *)malloc(strlen(arr) + 1); memset(dic[i].word, 0, strlen(arr) + 1); strncpy(dic[i].word, arr, strlen(arr) + 1); //将单词的意思放到dic[i].trans中 memset(arr, 0, 1024); fgets(arr, 1024, fp); dic[i].trans = (char *)malloc(strlen(arr) + 1); memset(dic[i].trans, 0, strlen(arr) + 1); strncpy(dic[i].trans, arr, strlen(arr) + 1); i++; } ........(下面代码没写,从上面的循环崩的。) ``` 为啥会崩感觉没错啊!内存也充足。就是单词个数有11万个,但是每次运行在不同的地方崩掉,有时候循环100个单词,有时候循环2000个单词。 以下是dict.txt中一部分内容: ``` #a Trans:art. 一;字母A #a.m. Trans:n. 上午 #a/c Trans:n. 往来帐户@往来:come - and - go; contact; #aardvark Trans:n. 土猪 #aardwolf Trans:n. 土狼 #aasvogel Trans:n. 秃鹰之一种 #abaci Trans:n. 算盘 #aback Trans:ad. 向后地;朝后地 #abacus Trans:n. 算盘 #abaft Trans:ad. 向船尾@prep. 在...后 #abalone Trans:n. 鲍鱼 #abandon Trans:vt. 放弃;沉溺@n. 放任 #abandoned Trans:a. 被抛弃的;自弃的;自甘堕落的 #abandonee Trans:n. 被遗弃者;被委付者 #abandoner Trans:n. 遗弃者;委付者 #abandonment Trans:n. 放弃;自暴自弃;放纵 #abas Trans:vt. 打倒 #abase Trans:vt. 降低...的地位;降低...的品格;贬抑 #abasement Trans:n. 贬抑;屈辱;谦卑 ```
C++哈夫曼编码译码器设计与实现并对哈夫曼树进行先序遍历。
现在就是差一个先序遍历的要求没有做到 ``` #include<stdio.h> #include<string.h> #include<stdlib.h> //树结点定义 typedef struct { int weight; int parent; int lchild; int rchild; }HTNode,*HuffmanTree; static char N[100];//用于保存正文 //哈弗曼编码,char型二级指针 typedef char **HuffmanCode; //封装最小权结点和次小权结点 typedef struct { int s1; int s2; }MinCode; //函数声明 void Error(char *message); HuffmanCode HuffmanCoding(HuffmanTree &HT,HuffmanCode HC,int *w,int n); MinCode Select(HuffmanTree HT,int n); //当输入1个结点时的错误提示 void Error(char *message) { fprintf(stderr,"Error:%s\n",message); //根据指定的格式,向输出流写入数据 exit(1); } //构造哈夫曼树HT,编码存放在HC中,w为权值,n为结点个数 HuffmanCode HuffmanCoding(HuffmanTree &HT,HuffmanCode HC,int *w,int n) { int i,s1=0,s2=0; HuffmanTree p; char *cd; int f,c,start,m; MinCode min; if(n<=1) { Error("Code too small!");//只有一个结点不进行编码,直接exit(1)退出。 } m=2*n-1;//哈弗曼编码需要开辟的结点大小为2n-1 HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//开辟哈夫曼树结点空间 m+1 ,动态内存分配。 //初始化n个叶子结点,w[0] = 0,main函数已赋值 for(p=HT,i=0;i<=n;i++,p++,w++) { p->weight=*w; p->parent=0; p->lchild=0; p->rchild=0; } //将n-1个非叶子结点的初始化 for(;i<=m;i++,p++) { p->weight=0; p->parent=0; p->lchild=0; p->rchild=0; } //构造哈夫曼树 for(i=n+1;i<=m;i++) { min=Select(HT,i-1);//找出最小和次小的两个结点 s1=min.s1 ; //最小结点下标 s2=min.s2;//次小结点下标 HT[s1].parent=i; HT[s2].parent=i; HT[i].lchild=s1; HT[i].rchild=s2; HT[i].weight=HT[s1].weight+HT[s2].weight; } //打印哈弗曼树 printf("HT List:\n"); printf("Number\t\tweight\t\tparent\t\tlchild\t\trchild\n"); for(i=1;i<=m;i++) { printf("%d\t\t%d\t\t%d\t\t%d\t\t%d\t\n",i,HT[i].weight,HT[i].parent,HT[i].lchild,HT[i].rchild); } //从叶子结点到根节点求每个字符的哈弗曼编码 HC=(HuffmanCode)malloc((n+1)*sizeof(char *)); cd=(char *)malloc(n*sizeof(char *));//为哈弗曼编码动态分配空间 cd[n-1]='\0';//如:3个结点编码最长为2。cd[3-1] = '\0'; //求叶子结点的哈弗曼编码 for(i=1;i<=n;i++) { start=n-1; //定义左子树为0,右子树为1 /* 从最下面的1号节点开始往顶部编码(逆序存放),然后编码2号节点,3号...... */ for(c=i,f=HT[i].parent; f!=0; c=f,f=HT[f].parent) { if(HT[f].lchild==c) cd[--start]='0'; else cd[--start]='1'; } //为第i个字符分配编码空间 HC[i]=(char *)malloc((n-start)*sizeof(char *)); //将当前求出结点的哈弗曼编码复制到HC strcpy(HC[i],&cd[start]); } free(cd); return HC; } MinCode Select(HuffmanTree HT,int n) { int min,secmin; int temp = 0; int i,s1,s2,tempi = 0; MinCode code ; s1=1; s2=1; min = 9999; //找出权值最小的结点,下标保存在s1中 for(i=1;i<=n;i++) { if(HT[i].weight<min && HT[i].parent==0) { min=HT[i].weight; s1=i; } } secmin = 9999; //找出权值次小的结点,下标保存在s2中 for(i=1;i<=n;i++) { if((HT[i].weight<secmin) && (i!=s1) && HT[i].parent==0) { secmin=HT[i].weight; s2=i; } } //放进封装中 code.s1=s1; code.s2=s2; return code; } void HuffmanTranslateCoding(HuffmanTree HT, int n,char* ch) {//译码过程 int m=2*n-1; int i,j=0; printf("After Translation:"); while(ch[j]!='\0')//ch[]:你输入的要译码的0101010串 { i=m; while(0 != HT[i].lchild && 0 != HT[i].rchild)//从顶部找到最下面 { if('0' == ch[j])//0 往左子树走 { i=HT[i].lchild; } else//1 往右子树走 { i=HT[i].rchild; } ++j;//下一个路径 } printf("%c",N[i-1]);//打印出来 } printf("\n"); } void main() { HuffmanTree HT=NULL; HuffmanCode HC=NULL; int *w=NULL; int i,n; char tran[100]; printf("Input N(char):"); gets(N); fflush(stdin); n = strlen(N); w=(int *)malloc((n+1)*sizeof(int *));//开辟n+1个长度的int指针空间 w[0]=0; printf("Enter weight:\n"); //输入结点权值 for(i=1;i<=n;i++) { printf("w[%d]=",i); scanf("%d",&w[i]); } fflush(stdin); //清空输入缓冲区 //构造哈夫曼树HT,编码存放在HC中,w为权值,n为结点个数 HC=HuffmanCoding(HT,HC,w,n); //输出哈弗曼编码 printf("HuffmanCode:\n"); printf("Number\t\tWeight\t\tCode\n"); for(i=1;i<=n;i++) { printf("%c\t\t%d\t\t%s\n",N[i-1],w[i],HC[i]); } fflush(stdin); //译码过程 printf("Input HuffmanTranslateCoding:"); gets(tran); HuffmanTranslateCoding(HT, n, tran); return; } ```题目要求:九、哈夫曼编码译码器设计与实现 编写程序设计哈夫曼编码译码器。 (1)根据输入的权值建立哈夫曼树。 (2)对建立好的哈夫曼树进行先序遍历。 (3)利用建好的哈夫曼树生成哈夫曼编码,并显示生成的各字符的哈夫曼编码。 (4)根据输入的字符进行译码。 (5)显示功能:以先序遍历的顺序显示建立好的哈夫曼树。显示哈夫曼编码和译码的结果。
Kafka实战(三) - Kafka的自我修养与定位
Apache Kafka是消息引擎系统,也是一个分布式流处理平台(Distributed Streaming Platform) Kafka是LinkedIn公司内部孵化的项目。LinkedIn最开始有强烈的数据强实时处理方面的需求,其内部的诸多子系统要执行多种类型的数据处理与分析,主要包括业务系统和应用程序性能监控,以及用户行为数据处理等。 遇到的主要问题: 数据正确性不足 数据的收集主要...
volatile 与 synchronize 详解
Java支持多个线程同时访问一个对象或者对象的成员变量,由于每个线程可以拥有这个变量的拷贝(虽然对象以及成员变量分配的内存是在共享内存中的,但是每个执行的线程还是可以拥有一份拷贝,这样做的目的是加速程序的执行,这是现代多核处理器的一个显著特性),所以程序在执行过程中,一个线程看到的变量并不一定是最新的。 volatile 关键字volatile可以用来修饰字段(成员变量),就是告知程序任何对该变量...
Java学习的正确打开方式
在博主认为,对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章中,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍,博客次之,这又是一个层次了,这里暂时不提后面再谈。博主将为各位入门java保驾护航,各位只管冲鸭!!!上天是公平的,只要不辜负时间,时间自然不会辜负你。 何谓学习?博主所理解的学习,它是一个过程,是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。
程序员必须掌握的核心算法有哪些?
由于我之前一直强调数据结构以及算法学习的重要性,所以就有一些读者经常问我,数据结构与算法应该要学习到哪个程度呢?,说实话,这个问题我不知道要怎么回答你,主要取决于你想学习到哪些程度,不过针对这个问题,我稍微总结一下我学过的算法知识点,以及我觉得值得学习的算法。这些算法与数据结构的学习大多数是零散的,并没有一本把他们全部覆盖的书籍。下面是我觉得值得学习的一些算法以及数据结构,当然,我也会整理一些看过...
有哪些让程序员受益终生的建议
从业五年多,辗转两个大厂,出过书,创过业,从技术小白成长为基层管理,联合几个业内大牛回答下这个问题,希望能帮到大家,记得帮我点赞哦。 敲黑板!!!读了这篇文章,你将知道如何才能进大厂,如何实现财务自由,如何在工作中游刃有余,这篇文章很长,但绝对是精品,记得帮我点赞哦!!!! 一腔肺腑之言,能看进去多少,就看你自己了!!! 目录: 在校生篇: 为什么要尽量进大厂? 如何选择语言及方...
大学四年自学走来,这些私藏的实用工具/学习网站我贡献出来了
大学四年,看课本是不可能一直看课本的了,对于学习,特别是自学,善于搜索网上的一些资源来辅助,还是非常有必要的,下面我就把这几年私藏的各种资源,网站贡献出来给你们。主要有:电子书搜索、实用工具、在线视频学习网站、非视频学习网站、软件下载、面试/求职必备网站。 注意:文中提到的所有资源,文末我都给你整理好了,你们只管拿去,如果觉得不错,转发、分享就是最大的支持了。 一、电子书搜索 对于大部分程序员...
linux系列之常用运维命令整理笔录
本博客记录工作中需要的linux运维命令,大学时候开始接触linux,会一些基本操作,可是都没有整理起来,加上是做开发,不做运维,有些命令忘记了,所以现在整理成博客,当然vi,文件操作等就不介绍了,慢慢积累一些其它拓展的命令,博客不定时更新 free -m 其中:m表示兆,也可以用g,注意都要小写 Men:表示物理内存统计 total:表示物理内存总数(total=used+free) use...
比特币原理详解
一、什么是比特币 比特币是一种电子货币,是一种基于密码学的货币,在2008年11月1日由中本聪发表比特币白皮书,文中提出了一种去中心化的电子记账系统,我们平时的电子现金是银行来记账,因为银行的背后是国家信用。去中心化电子记账系统是参与者共同记账。比特币可以防止主权危机、信用风险。其好处不多做赘述,这一层面介绍的文章很多,本文主要从更深层的技术原理角度进行介绍。 二、问题引入 假设现有4个人...
GitHub开源史上最大规模中文知识图谱
近日,一直致力于知识图谱研究的 OwnThink 平台在 Github 上开源了史上最大规模 1.4 亿中文知识图谱,其中数据是以(实体、属性、值),(实体、关系、实体)混合的形式组织,数据格式采用 csv 格式。 到目前为止,OwnThink 项目开放了对话机器人、知识图谱、语义理解、自然语言处理工具。知识图谱融合了两千五百多万的实体,拥有亿级别的实体属性关系,机器人采用了基于知识图谱的语义感...
程序员接私活怎样防止做完了不给钱?
首先跟大家说明一点,我们做 IT 类的外包开发,是非标品开发,所以很有可能在开发过程中会有这样那样的需求修改,而这种需求修改很容易造成扯皮,进而影响到费用支付,甚至出现做完了项目收不到钱的情况。 那么,怎么保证自己的薪酬安全呢? 我们在开工前,一定要做好一些证据方面的准备(也就是“讨薪”的理论依据),这其中最重要的就是需求文档和验收标准。一定要让需求方提供这两个文档资料作为开发的基础。之后开发...
网页实现一个简单的音乐播放器(大佬别看。(⊙﹏⊙))
今天闲着无事,就想写点东西。然后听了下歌,就打算写个播放器。 于是乎用h5 audio的加上js简单的播放器完工了。 演示地点演示 html代码如下` music 这个年纪 七月的风 音乐 ` 然后就是css`*{ margin: 0; padding: 0; text-decoration: none; list-...
微信支付崩溃了,但是更让马化腾和张小龙崩溃的竟然是……
loonggg读完需要3分钟速读仅需1分钟事件还得还原到昨天晚上,10 月 29 日晚上 20:09-21:14 之间,微信支付发生故障,全国微信支付交易无法正常进行。然...
Python十大装B语法
Python 是一种代表简单思想的语言,其语法相对简单,很容易上手。不过,如果就此小视 Python 语法的精妙和深邃,那就大错特错了。本文精心筛选了最能展现 Python 语法之精妙的十个知识点,并附上详细的实例代码。如能在实战中融会贯通、灵活使用,必将使代码更为精炼、高效,同时也会极大提升代码B格,使之看上去更老练,读起来更优雅。
数据库优化 - SQL优化
以实际SQL入手,带你一步一步走上SQL优化之路!
2019年11月中国大陆编程语言排行榜
2019年11月2日,我统计了某招聘网站,获得有效程序员招聘数据9万条。针对招聘信息,提取编程语言关键字,并统计如下: 编程语言比例 rank pl_ percentage 1 java 33.62% 2 cpp 16.42% 3 c_sharp 12.82% 4 javascript 12.31% 5 python 7.93% 6 go 7.25% 7 p...
通俗易懂地给女朋友讲:线程池的内部原理
餐盘在灯光的照耀下格外晶莹洁白,女朋友拿起红酒杯轻轻地抿了一小口,对我说:“经常听你说线程池,到底线程池到底是个什么原理?”
《奇巧淫技》系列-python!!每天早上八点自动发送天气预报邮件到QQ邮箱
将代码部署服务器,每日早上定时获取到天气数据,并发送到邮箱。 也可以说是一个小型人工智障。 知识可以运用在不同地方,不一定非是天气预报。
经典算法(5)杨辉三角
杨辉三角 是经典算法,这篇博客对它的算法思想进行了讲解,并有完整的代码实现。
英特尔不为人知的 B 面
从 PC 时代至今,众人只知在 CPU、GPU、XPU、制程、工艺等战场中,英特尔在与同行硬件芯片制造商们的竞争中杀出重围,且在不断的成长进化中,成为全球知名的半导体公司。殊不知,在「刚硬」的背后,英特尔「柔性」的软件早已经做到了全方位的支持与支撑,并持续发挥独特的生态价值,推动产业合作共赢。 而对于这一不知人知的 B 面,很多人将其称之为英特尔隐形的翅膀,虽低调,但是影响力却不容小觑。 那么,在...
腾讯算法面试题:64匹马8个跑道需要多少轮才能选出最快的四匹?
昨天,有网友私信我,说去阿里面试,彻底的被打击到了。问了为什么网上大量使用ThreadLocal的源码都会加上private static?他被难住了,因为他从来都没有考虑过这个问题。无独有偶,今天笔者又发现有网友吐槽了一道腾讯的面试题,我们一起来看看。 腾讯算法面试题:64匹马8个跑道需要多少轮才能选出最快的四匹? 在互联网职场论坛,一名程序员发帖求助到。二面腾讯,其中一个算法题:64匹...
面试官:你连RESTful都不知道我怎么敢要你?
干货,2019 RESTful最贱实践
刷了几千道算法题,这些我私藏的刷题网站都在这里了!
遥想当年,机缘巧合入了 ACM 的坑,周边巨擘林立,从此过上了"天天被虐似死狗"的生活… 然而我是谁,我可是死狗中的战斗鸡,智力不够那刷题来凑,开始了夜以继日哼哧哼哧刷题的日子,从此"读题与提交齐飞, AC 与 WA 一色 ",我惊喜的发现被题虐既刺激又有快感,那一刻我泪流满面。这么好的事儿作为一个正直的人绝不能自己独享,经过激烈的颅内斗争,我决定把我私藏的十几个 T 的,阿不,十几个刷题网...
为啥国人偏爱Mybatis,而老外喜欢Hibernate/JPA呢?
关于SQL和ORM的争论,永远都不会终止,我也一直在思考这个问题。昨天又跟群里的小伙伴进行了一番讨论,感触还是有一些,于是就有了今天这篇文。 声明:本文不会下关于Mybatis和JPA两个持久层框架哪个更好这样的结论。只是摆事实,讲道理,所以,请各位看官勿喷。 一、事件起因 关于Mybatis和JPA孰优孰劣的问题,争论已经很多年了。一直也没有结论,毕竟每个人的喜好和习惯是大不相同的。我也看...
白话阿里巴巴Java开发手册高级篇
不久前,阿里巴巴发布了《阿里巴巴Java开发手册》,总结了阿里巴巴内部实际项目开发过程中开发人员应该遵守的研发流程规范,这些流程规范在一定程度上能够保证最终的项目交付质量,通过在时间中总结模式,并推广给广大开发人员,来避免研发人员在实践中容易犯的错误,确保最终在大规模协作的项目中达成既定目标。 无独有偶,笔者去年在公司里负责升级和制定研发流程、设计模板、设计标准、代码标准等规范,并在实际工作中进行...
SQL-小白最佳入门sql查询一
不要偷偷的查询我的个人资料,即使你再喜欢我,也不要这样,真的不好;
项目中的if else太多了,该怎么重构?
介绍 最近跟着公司的大佬开发了一款IM系统,类似QQ和微信哈,就是聊天软件。我们有一部分业务逻辑是这样的 if (msgType = "文本") { // dosomething } else if(msgType = "图片") { // doshomething } else if(msgType = "视频") { // doshomething } else { // doshom...
Nginx 原理和架构
Nginx 是一个免费的,开源的,高性能的 HTTP 服务器和反向代理,以及 IMAP / POP3 代理服务器。Nginx 以其高性能,稳定性,丰富的功能,简单的配置和低资源消耗而闻名。 Nginx 的整体架构 Nginx 里有一个 master 进程和多个 worker 进程。master 进程并不处理网络请求,主要负责调度工作进程:加载配置、启动工作进程及非停升级。worker 进程负责处...
YouTube排名第一的励志英文演讲《Dream(梦想)》
Idon’t know what that dream is that you have, I don't care how disappointing it might have been as you've been working toward that dream,but that dream that you’re holding in your mind, that it’s po...
“狗屁不通文章生成器”登顶GitHub热榜,分分钟写出万字形式主义大作
一、垃圾文字生成器介绍 最近在浏览GitHub的时候,发现了这样一个骨骼清奇的雷人项目,而且热度还特别高。 项目中文名:狗屁不通文章生成器 项目英文名:BullshitGenerator 根据作者的介绍,他是偶尔需要一些中文文字用于GUI开发时测试文本渲染,因此开发了这个废话生成器。但由于生成的废话实在是太过富于哲理,所以最近已经被小伙伴们给玩坏了。 他的文风可能是这样的: 你发现,...
程序员:我终于知道post和get的区别
是一个老生常谈的话题,然而随着不断的学习,对于以前的认识有很多误区,所以还是需要不断地总结的,学而时习之,不亦说乎
相关热词 c# 引用mysql c#动态加载非托管dll c# 两个表数据同步 c# 返回浮点json c# imap 链接状态 c# 漂亮字 c# 上取整 除法 c#substring c#中延时关闭 c#线段拖拉
立即提问