模块化代码（封装 __attribute__ constructor&destructor ）

最新推荐文章于 2023-02-07 20:15:50 发布
最新推荐文章于 2023-02-07 20:15:50 发布
阅读量271 收藏
点赞数
分类专栏： C/C++ LINUX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y7u8t6/article/details/88043399
版权
LINUX 同时被 2 个专栏收录
31 篇文章 0 订阅
订阅专栏
C/C++
28 篇文章 0 订阅
订阅专栏

constructor / destructor

意思是: 构造器和析构器;constructor修饰的函数会在main函数之前执行,destructor修饰的函数会在程序exit前调用.
示例如下:

int main(int argc, char * argv[]) {
    @autoreleasepool {
        NSLog(@"main");
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}
 
__attribute__((constructor))
void  before(){
    NSLog(@"before main");
}
 
__attribute__((destructor))
void  after(){
    NSLog(@"after main");
}
 
//在viewController中调用exit
- (void)viewDidLoad {
    [super viewDidLoad];
 
    exit(0);
}
输出如下:
 
2016-07-21 21:49:17.446 Study[14162:5415982] before main
2016-07-21 21:49:17.447 Study[14162:5415982] main
2016-07-21 21:49:17.534 Study[14162:5415982] after main

因此可以根据每一个模块封装成对应的加载接口和卸载接口。

太懒了，直接贴代码。。

版本一，初步封装

#include <stdio.h>

typedef struct ks_module_info
{
	const char* name;
	unsigned char priority;
	int (*load)(void);
	int (*unload)(void);
}ks_module_info;

void ks_module_register(const struct ks_module_info *info);
void ks_module_unregister(const struct ks_module_info *info);

void ks_module_register(const struct ks_module_info* info)
{
	printf("##### before main, ks_module_register ######\n");
    info->load();
}
void ks_module_unregister(const struct ks_module_info* info)
{
	printf("##### after main, ks_module_unregister ######\n");
    info->unload();
}

#define KS_MODULE_INFO(name, load_pri, load_func, unload_func)	\
	static struct ks_module_info __mod_info = {	\
		name,					\
		load_pri,				\
		load_func,				\
		unload_func,			\
	};							\
	static void  __attribute__((constructor)) __reg_module(void) \
	{ \
		ks_module_register(&__mod_info); \
	} \
	static void  __attribute__((destructor)) __unreg_module(void) \
	{ \
		ks_module_unregister(&__mod_info); \
	}


    
#define MD_FAILOVER_NAME  "mod_failover"
enum MD_PRIORITY
{
	MD_DAEMON_PRIORITY = 1,
	MD_FAILOVER_PRIORITY,
};

static int unload_module(void)
{
    printf("########### unload module ########\n");
    return 0;
}

static int load_module(void)
{
    printf("########### load module ########\n");
	return 0;
}

    
int main(int argc,char **argv)
{   
    printf("hello world!\n");
    return 0;
}

KS_MODULE_INFO(MD_FAILOVER_NAME, MD_FAILOVER_PRIORITY, load_module, unload_module);

版本二，实际项目中可能运用的方法

工程文件

kscore.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "kscore.h"
#include "ksstd.h"
#include "ksmodule.h"


#define MAX_STR_LEN 64

static void load_modules()
{
	int i = 0;
    int modulecount = 0;
	struct ks_module_info *modules = NULL;
	
	ks_get_modules(&modules, &modulecount);
	if (!modules || !modulecount)
	{
		ksdebug(DEBUG_ERR, "get modules fail.");
		return;
	}

	for (i = 0; i < modulecount; i++)
	{
		if (!modules[i].name)
			continue;
		modules[i].load();
	}
}

static void unload_modules()
{
	int i;
    int modulecount = 0;
	struct ks_module_info *modules = NULL;
	
	ks_get_modules(&modules, &modulecount);
	if (!modules || !modulecount)
		return;
	
	i = modulecount-1;
	for ( ; i >= 0; i--)
	{
		if (!modules[i].name) 
			continue;
		modules[i].unload();
	}	
}

//
//
int ks_core_start(int verify)
{
	load_modules();	
	return 0;
}

int ks_core_stop()
{
	unload_modules();
	
	return 0;
}

int ks_core_unload_module(int priority)
{
	int i, modulecount = 0;
	struct ks_module_info *modules = NULL;
	
    ksprintf("==================ks_core_unload_module:%d====================", priority);
	ks_get_modules(&modules, &modulecount);
	if (!modules || !modulecount)
		return -1;
	
	i = modulecount-1;
	for ( ; i >= 0; i--)
	{
		if (!modules[i].name) 
			continue;
		if(priority == modules[i].priority)
			modules[i].unload();
	}	
	
	return 0;
}

kscore.h

#ifndef _KS_CORE_H_
#define _KS_CORE_H_


#ifdef __cplusplus
extern "C"
{
#endif

int ks_core_start();
int ks_core_stop();
int ks_core_unload_module(int priority);

#ifdef __cplusplus
}
#endif

#endif

ksdefs.h

#ifndef _KS_CORE_H_
#define _KS_CORE_H_


#ifdef __cplusplus
extern "C"
{
#endif

int ks_core_start();
int ks_core_stop();
int ks_core_unload_module(int priority);

#ifdef __cplusplus
}
#endif

#endif

ksmodule.c

#include "ksmodule.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "ksstd.h"

static int ks_module_debug = 0;
static int global_md_cnt = 0;
static struct ks_module_info global_modules[MAX_KS_MODULE] = {{0}};

static struct ks_module_info* find_module(const char* name)
{
	int i = 0;
	for ( ; i < MAX_KS_MODULE; i++)
	{
		if (global_modules[i].name && strcasecmp(global_modules[i].name, name)==0) 
			return &global_modules[i];
	}
	return NULL;
}

static void insert_module_info(struct ks_module_info modules[MAX_KS_MODULE], struct ks_module_info* info)
{
	int idx = 0;
	for ( ; idx < global_md_cnt; idx++)
	{
		if (info->priority > modules[idx].priority)
			break;
	}
	int move = global_md_cnt;
	for ( ; move > idx; move--)
	{
		memcpy(modules+move, modules+move-1, sizeof(struct ks_module_info));
	}
	memcpy(modules+idx, info, sizeof(struct ks_module_info));
	global_md_cnt++;
    
    if (ks_module_debug)
    {
        int i = 0;
        for ( ; i < global_md_cnt; i++)
        {
            ksprintf("module-%d name:%s", i+1, modules[i].name);
        }	
    }	
}

void ks_module_register(const struct ks_module_info* info)
{
	if (!info || !info->name) 
		return;
	if (find_module(info->name)) 
		return;
	if (global_md_cnt >= MAX_KS_MODULE)
		return;
	int i = 0;
	for ( ; i < MAX_KS_MODULE; i++)
	{
		if (global_modules[i].name)
			continue;
		insert_module_info(global_modules, (struct ks_module_info*)(info));
		break;
	}
}
void ks_module_unregister(const struct ks_module_info* info)
{
	if (!info || !info->name) 
		return;
	struct ks_module_info* mod = find_module(info->name);
	if (!mod) 
		return;
	memset(mod, 0, sizeof(struct ks_module_info));
	global_md_cnt--;
}

int ks_get_modules(struct ks_module_info **modules, int *capability)
{
	if (!modules || !capability) 
		return -1;
	*modules	= global_modules;
	*capability	= global_md_cnt;
	return 0;
}

ksmodule.h

/* 
 * Filename:      	ksmodule
 * Created at:    	2019.02.26
 * Description:   	module controller.
 * Author:        	ks
 * Copyright (C)  	xxl
 * ****************************************************************/
#ifndef _KS_MODULE_H_
#define _KS_MODULE_H_

#ifdef __cplusplus
extern "C"
{
#endif

#define KS_MODULE_CONF  "/mnt/nand/etc/modules.conf" 
#define MAX_KS_MODULE   4


enum MD_PRIORITY
{
	MD_PRIORITY_LOG         = 1,
	MD_PRIORITY_SEARCH      = 2,
	MD_PRIORITY_SYSCONF     = 3,
	MD_PRIORITY_FAILOVER    = 4,
};


#define MD_NAME_LOG         "log"
#define MD_NAME_SEARCH      "search"
#define MD_NAME_SYSCONF		"sysconf"
#define MD_NAME_FAILOVER    "failover"


typedef struct ks_module_info
{
	const char* name;
	unsigned char priority;
	int (*load)(void);
	int (*unload)(void);
}ks_module_info;

void ks_module_register(const struct ks_module_info *info);
void ks_module_unregister(const struct ks_module_info *info);

#define KS_MODULE_INFO(name, load_pri, load_func, unload_func)	\
	static struct ks_module_info __mod_info = {	\
		name,					\
		load_pri,				\
		load_func,				\
		unload_func,			\
	};							\
	static void  __attribute__((constructor)) __reg_module(void) \
	{ \
		ks_module_register(&__mod_info); \
	} \
	static void  __attribute__((destructor)) __unreg_module(void) \
	{ \
		ks_module_unregister(&__mod_info); \
	}

int ks_get_modules(struct ks_module_info **modules, int *capability);

#ifdef __cplusplus
}
#endif

#endif

ksstd.c

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "ksstd.h"

void time_to_string(int ntime, char stime[32])
{
	struct tm temp;

	localtime_r((long*)&ntime, &temp);
	snprintf(stime, 32, "%4d-%02d-%02d %02d:%02d:%02d", 
		temp.tm_year + 1900, temp.tm_mon + 1, temp.tm_mday, temp.tm_hour, temp.tm_min, temp.tm_sec);
}

void time_to_string_ks(char stime[32])
{
	struct tm temp;
	struct timeval tv;
	gettimeofday(&tv, NULL);
	localtime_r(&tv.tv_sec, &temp);
	snprintf(stime, 32, "%4d-%02d-%02d %02d:%02d:%02d.%03d", 
		temp.tm_year + 1900, temp.tm_mon + 1, temp.tm_mday, temp.tm_hour, temp.tm_min, temp.tm_sec,(int)(tv.tv_usec/1000));
}

ksstd.h

#ifndef _KS_STD_H_
#define _KS_STD_H_

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

#ifdef __cplusplus
extern "C"
{
#endif

void time_to_string(int ntime, char stime[32]);
void time_to_string_ks(char stime[32]);

/* Word color define */
#define YELLOW			"\033[0;33m"	// yellow
#define GRAY 			"\033[2;37m"
#define DGREEN 			"\033[1;32m"
#define GREEN 			"\033[0;32m"
#define DARKGRAY 		"\033[0;30m"
//#define BLACK 		"\033[0;39m"
#define BLACK 			"\033[2;30m" 	// not faint black
#define NOCOLOR 		"\033[0;39m \n"
#define CLRCOLOR		"\033[0;39m "
//#define NOCOLOR 		"\033[0m \n"
#define BLUE 			"\033[1;34m"
#define DBLUE 			"\033[2;34m"	
#define RED 			"\033[0;31m"
#define BOLD 			"\033[1m"
#define UNDERLINE 		"\033[4m"
#define CLS 			"\014"
#define NEWLINE 		"\r\n"


#define DEBUG_LEVEL_DEFAULT 0xffffffff
extern unsigned int global_debug_mask;
typedef void (*hook_print)(char* format, ...);
extern hook_print global_debug_hook;
#define ERR_LOG_PATH	"./err_log.txt"

enum DEBUG_LEVEL
{
	DEBUG_ERR = 0x01,
	DEBUG_WRN = 0x02,
	DEBUG_INF = 0x04,
	DEBUG_GUI = 0x08,
	DEBUG_POE = 0X10,
};



#define _log_err(level, prefix, format, ...) \
	do{\
		if(global_debug_mask & level){\
			char stime[32] = {0};\
			char log[1024] = {0};\
			char cmd[128] = {0};\
			int filesize = -1;\
			FILE * hfile = NULL;\
			hfile = fopen(ERR_LOG_PATH, "a");\
			if(hfile){\
				fseek(hfile, 0L, SEEK_END);\
    			filesize = ftell(hfile);\
				time_to_string(time(0), stime);\
				snprintf(log, sizeof(log), "[%s%s %d==func:%s file:%s line:%d]==" format "\n", \
				prefix, stime, getpid(), __func__, __FILE__, __LINE__, ##__VA_ARGS__); \
				fwrite(log, 1, strlen(log), hfile);\
				fflush(hfile);\
				fclose(hfile);\
				snprintf(cmd, sizeof(cmd), "rm -rf %s", ERR_LOG_PATH);\
				if(filesize > 1024*1024)\
					system(cmd);\
			}\
		}\
    }while(0);
    
#define mslogerr(level, format, ...) \
	if(level == DEBUG_ERR){\
		_debug(level,  "ERR:",RED format CLRCOLOR, ##__VA_ARGS__)\
		_log_err(level, "ERR:", format, ##__VA_ARGS__)\
	}else if(level == DEBUG_WRN)\
		_log_err(level, "WRN:", format, ##__VA_ARGS__)\
	else\
		_log_err(level, "INF:", format, ##__VA_ARGS__)

        
#define _debug(level, prefix, format, ...) \
	do{\
		if(global_debug_mask & level){\
			char stime[32] = {0};\
			time_to_string_ks(stime);\
			printf("[%s%s %d==func:%12s file:%12s line:%6d]==" format "\n", \
			prefix, stime, getpid(), __func__, __FILE__, __LINE__, ##__VA_ARGS__); \
            if(global_debug_hook)\
				global_debug_hook("[%s%s %d==func:%12s file:%12s line:%6d]==" format "\n",\
				prefix, stime, getpid(), __func__, __FILE__, __LINE__, ##__VA_ARGS__);\
		}\
    }while(0);		

#define ksdebug(level, format, ...) \
	do { \
		switch(level) \
		{ \
		case DEBUG_ERR: \
			_debug(level,  "ERR:",RED format CLRCOLOR, ##__VA_ARGS__); \
			_log_err(level, "ERR:", format, ##__VA_ARGS__); \
			break; \
		case DEBUG_WRN: \
			_debug(level, "WRN:",YELLOW format CLRCOLOR, ##__VA_ARGS__); \
			break; \
		case DEBUG_GUI: \
			_debug(level, "GUI:",GREEN format CLRCOLOR, ##__VA_ARGS__); \
			break; \
		default: \
			_debug(level, "INF:", format, ##__VA_ARGS__); \
			break; \
		} \
	}while(0)		
	

#define ksprintf(format, ...) \
    do{\
		char stime[32] = {0};\
		time_to_string(time(0), stime);\
		printf("[%s %d==func:%s file:%s line:%d]==" format "\n", \
		stime, getpid(), __func__, __FILE__, __LINE__, ##__VA_ARGS__); \
    }while(0)
        
    
#ifdef __cplusplus
}
#endif


#endif

main.c

#include <signal.h>
#include <string.h>
#include <stdio.h>
#include "ksstd.h"
//#include "kscore.h"

int g_exitcore = 0;
unsigned int global_debug_mask = DEBUG_LEVEL_DEFAULT;
hook_print global_debug_hook = 0;
extern int global_record_run;
static int global_module_debug = 0;

static void signal_handler(int signal)
{
	if(signal != SIGPIPE)
		printf("mscore recv signal %d\n", signal);
	switch(signal)
	{
		case SIGINT:
		case SIGTERM:
		case SIGKILL:
			g_exitcore = 1;
			break;
		case SIGUSR2:
			g_exitcore = 2;
			break;
		case SIGPIPE:
			break;
		default:
			break;
	}	
}

static void signal_backtrace(int signo)
{
	time_t t = time(NULL);
	
	if(signo == 11)
	{
		printf("kscore received signal: %d, backtrace stack at time: %s...\n",signo, ctime(&t));
		ksdebug(DEBUG_ERR, "kscore received signal: %d, backtrace stack at time: %s...\n",signo, ctime(&t));
	}
	
	exit(0);
}

static void set_core_signal()
{
	signal(SIGINT,  signal_handler);	//2//
	signal(SIGTERM, signal_handler);	//15
	signal(SIGKILL, signal_handler);	//9
	signal(SIGPIPE, signal_handler);	//13
	signal(SIGUSR2, signal_handler);	//12
	
	signal(SIGSEGV, signal_backtrace);	//11
	signal(SIGBUS, signal_backtrace);	// 7
	signal(SIGILL, signal_backtrace);	// 4
	signal(SIGSTKFLT, signal_backtrace);// 16
	signal(SIGFPE, signal_backtrace);	// 8
	signal(SIGABRT, signal_backtrace);	//6
}

 
int main(int argc,char **argv)
{   
    ksprintf("hello world!");
    ks_core_start(1);

    set_core_signal();
    
    //maybe run a thread
    while (1)
    {
        if (g_exitcore)
        {
            break;
        }
        
        usleep(100*1000);//100ms
    }

    ks_core_stop();
    return 0;
}

mod_failover.c

/* 
 * Filename:      	mod_failover
 * Created at:    	2019.02.26
 * Description:        failover module
 * Author:        	ks
 * Copyright (C)  	xxl
 * *******************************************************/

#include <string.h>
#include "ksmodule.h"
#include "ksstd.h"


struct md_failover_conf
{
	int loaded;
	int debug;
};
static struct md_failover_conf g_failover_conf = {0};

static int init_module()
{
	return 0;
}

static int uninit_module()
{
	return 0;
}


static int load_module(void)
{
	if(g_failover_conf.loaded)
		return 1;

	ksprintf("====load module:%s====", MD_NAME_FAILOVER);

	g_failover_conf.loaded = 1;
	g_failover_conf.debug = 0;
	
	if(init_module() != 0)
	{
		ksdebug(DEBUG_WRN, "load module:%s failed.", MD_NAME_FAILOVER);
		g_failover_conf.loaded = 0;
		return -1;
	}

	return 0;
}

static int unload_module(void)
{
	if (g_failover_conf.loaded == 0)
		return 1;
	g_failover_conf.loaded = 0;

	uninit_module();
	ksprintf("====unload %s success.====", MD_NAME_FAILOVER);

	return 0;
}

KS_MODULE_INFO(MD_NAME_FAILOVER, MD_PRIORITY_FAILOVER, load_module, unload_module);

mod_log.c

/* 
 * Filename:      	mod_log
 * Created at:    	2019.02.26
 * Description:        log module
 * Author:        	ks
 * Copyright (C)  	xxl
 * *******************************************************/

#include <string.h>
#include "ksmodule.h"
#include "ksstd.h"


struct md_log_conf
{
	int loaded;
	int debug;
};
static struct md_log_conf g_log_conf = {0};

static int init_module()
{
	return 0;
}

static int uninit_module()
{
	return 0;
}


static int load_module(void)
{
	if(g_log_conf.loaded)
		return 1;

	ksprintf("====load module:%s====", MD_NAME_LOG);

	g_log_conf.loaded = 1;
	g_log_conf.debug = 0;
	
	if(init_module() != 0)
	{
		ksdebug(DEBUG_WRN, "load module:%s failed.", MD_NAME_LOG);
		g_log_conf.loaded = 0;
		return -1;
	}

	return 0;
}

static int unload_module(void)
{
	if (g_log_conf.loaded == 0)
		return 1;
	g_log_conf.loaded = 0;

	uninit_module();
	ksprintf("====unload %s success.====", MD_NAME_LOG);

	return 0;
}

KS_MODULE_INFO(MD_NAME_LOG, MD_PRIORITY_LOG, load_module, unload_module);

mod_search.c

/* 
 * Filename:      	mod_search
 * Created at:    	2019.02.26
 * Description:        search module
 * Author:        	ks
 * Copyright (C)  	xxl
 * *******************************************************/

#include <string.h>
#include "ksmodule.h"
#include "ksstd.h"


struct md_search_conf
{
	int loaded;
	int debug;
};
static struct md_search_conf g_search_conf = {0};

static int init_module()
{
	return 0;
}

static int uninit_module()
{
	return 0;
}


static int load_module(void)
{
	if(g_search_conf.loaded)
		return 1;

	ksprintf("====load module:%s====", MD_NAME_SEARCH);
    //int *x = NULL;
    //*x = 1;
	g_search_conf.loaded = 1;
	g_search_conf.debug = 0;
	
	if(init_module() != 0)
	{
		ksdebug(DEBUG_WRN, "load module:%s failed.", MD_NAME_SEARCH);
		g_search_conf.loaded = 0;
		return -1;
	}

	return 0;
}

static int unload_module(void)
{
	if (g_search_conf.loaded == 0)
		return 1;
	g_search_conf.loaded = 0;

	uninit_module();
	ksprintf("====unload %s success.====", MD_NAME_SEARCH);

	return 0;
}

KS_MODULE_INFO(MD_NAME_SEARCH, MD_PRIORITY_SEARCH, load_module, unload_module);

mod_sysconf.c

/* 
 * Filename:      	mod_sysconf
 * Created at:    	2019.02.26
 * Description:        sysconf module
 * Author:        	ks
 * Copyright (C)  	xxl
 * *******************************************************/

#include <string.h>
#include "ksmodule.h"
#include "ksstd.h"


struct md_sysconf_conf
{
	int loaded;
	int debug;
};
static struct md_sysconf_conf g_sysconf_conf = {0};

static int init_module()
{
	return 0;
}

static int uninit_module()
{
	return 0;
}


static int load_module(void)
{
	if(g_sysconf_conf.loaded)
		return 1;

	ksprintf("====load module:%s====", MD_NAME_SYSCONF);

	g_sysconf_conf.loaded = 1;
	g_sysconf_conf.debug = 0;
	
	if(init_module() != 0)
	{
		ksdebug(DEBUG_WRN, "load module:%s failed.", MD_NAME_SYSCONF);
		g_sysconf_conf.loaded = 0;
		return -1;
	}

	return 0;
}

static int unload_module(void)
{
	if (g_sysconf_conf.loaded == 0)
		return 1;
	g_sysconf_conf.loaded = 0;

	uninit_module();
	ksprintf("====unload %s success.====", MD_NAME_SYSCONF);

	return 0;
}

KS_MODULE_INFO(MD_NAME_SYSCONF, MD_PRIORITY_SYSCONF, load_module, unload_module);

运行结果

虾虾林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码模块化-方法(method)
m0_62478822的博客
11-25 395
代码模块化-方法method **1、method的概念** Java方法的目的： 模块化 复用性 应用简单 2、语法 public static int add (int a,int b){ int c = a+b; return c; } public: 访问控制符 static: 静态 int: 方法的返回类型 add: 方法名称 int a,int b: 参数列表 大括号{ } : 作用域 3、方法的形参和实参 (int a, int b ); // a, b 为方法的形参–
代码模块化
不要停我的药
11-14 6095
模块化是把一个大的代码块拆分成若干个小片段（模块）的过程，然后就可以在其他模块中调用这些模块了。代码的模块化非常类似于数据的规范化，得到的好处是相同的，而且还有一些额外的优点。利用模块化，我们的代码可以：      重用性更好        通过把一大段代码或者整个程序分解成独立的"即插即用"的组件，我们经常发现，许多模块其实可以被当前应用中的其他程序使用。只要有良好的设计，这些工具程序甚至可以用
模块化代码
gelad_w的博客
08-14 488
时隔多日，我们又见面了，这一章主要说明一下代码的模块化，也就 .h文件和.c文件的运用。 文章目录一、.h文件 和 .c文件二、.h文件格式三、使用 一、.h文件 和 .c文件 在之前的篇章里，我们只创建了一个 main.c 文件，所有的 define 声明和自定义函数以及实现逻辑全放在了这个 .c 文件里，代码量少还好，如果代码量非常大，又定义了好多自定义函数，那么整个代码会格外的杂乱，也不方便后期的维护。 因此，我们用 .c 文件和 .h 文件将代码做好规划，.h 文件里只放自定义函数的声明和一些自定义
JS 代码模块化
qq_36587340的博客
09-07 280
var module = (function() { var N = 5; function print(x) { console.log("The result is: " + x); } function add(a) { var x = a + N; print(x); } return { ...
代码模块化-方法（method）
weixin_53310322的博客
11-25 1539
代码模块化-方法（method）1.概念2.结构3.语法3.1常见语法错误 1.概念 ​ 将一个功能抽取出来，放在类中的大括号中，形成一个独立的功能，当需要使用该功能时，则调用它，这样可以增强代码的复用性（重复利用），并解决代码的冗余现象。 2.结构 3.语法 public static int add(int a, int b) { int d = a + b; return d; } 1.public:访问控制符 2.static:静态 3.int:方法的返回类型 4.add:方法名
muwj_python_hm_mxdx:面向对象
03-10
它是一种编程范式，基于“对象”这一概念，将数据和处理数据的方法封装在一起，以实现代码的模块化和复用性。在Python中，一切都是对象，无论是基本类型如整数、字符串，还是自定义的类实例。 1. **类与对象**： -...
hw_python_oop
03-22
在Python中，面向对象编程是一种强大的工具，它使代码更加模块化，易于维护和扩展。通过理解和实践这些基本概念，开发者能够构建复杂、可复用的软件系统。对于学习者来说，理解并熟练运用这些OOP概念是提升编程技能...
hw_python_oop:冲刺2。
04-02
8. 构造函数（Constructor）：`__init__`是Python中的构造函数，用于初始化新创建的对象。 9. 析构函数（Destructor）：Python没有真正的析构函数，但`__del__`方法在对象被垃圾回收前调用。 10. 静态方法（Static...
python_classes
03-09
- 构造器（Constructor）：`__init__`是默认的构造器，用于初始化新创建的对象。 - 析构器（Destructor）：Python中没有真正的析构函数，但有一个`__del__`特殊方法，当对象即将被垃圾回收时会被调用。 9. **类...
PythonOOP:使用python代码回购以学习OOP
04-02
通过以上这些核心概念，我们可以创建出复杂的、模块化的代码结构，这正是Python OOP的魅力所在。在"PythonOOP-main"这个项目中，你可以期待看到如何实际应用这些概念的示例代码和练习，从而加深对Python面向对象编程...
代码大全（4）之模块化
woshibendangao的专栏
03-14 765
常见需要隐藏的信息： 1、容易被改动的区域 对硬件有依赖的地方；输入和输出；非标准语言特性；难以设计和实现的域；状态变量；数据规模限制；商业规则； 2、复杂的数据 对复杂数据的使用程度，主要取决于程序。 3、复杂的逻辑 隐含复杂的逻辑可言改善程序的可读性 4、在程序语言层次上的操作 一般在设计一组在程序语言语句层次上操作数据的子程序时，应该把对数据操作隐含在子程序组中，这样程序
模块化编程
Baoao_的博客
06-29 379
无
Java封装之构造方法Constructor
m0_63920681的博客
01-28 379
1.介绍构造方法: 当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。 2.构造方法的定义格式 修饰符 构造方法名(参数列表){ System.out.println("如果你调用我我就拍拍手") } 构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，且不需要void【它及其特殊】： public class Student{ private String name; private int age; //定义无参
随想007：模块化代码
最新发布
朱工的专栏
02-07 1316
你一定不止一次的听说过模块化代码。 理想的模块化代码高内聚低耦合、逻辑清晰、经过严格测试，易于复用 它被描述的像是无所不能，仿佛只要使用了模块化代码，你就可以节省大把开发时间，项目就能化腐朽为神奇。 以至于有些人了解模块化代码的优点后，惊喜的发现找到了一个可以无视人员素质又节省开发时间的终极方法：强制所有开发人员使用模块化代码
【java】代码模块化 方法
wdy00000的博客
12-30 564
【Python零基础快速入门系列 | 09】高级程序员绝世心法——模块化之函数封装
机器未来的博客
06-03 1795
常说万丈高楼平地起，编程也是一样，一个个的函数就像积木一样组合在一起，最终成为万丈高楼。 高内聚、低耦合基本是初级程序员走上高级程序员所必须要悟到的绝世心法。
类的接口与代码模块化
snvy的专栏
02-07 894
接口是模块化编程的基础，它是各模块之间的通信媒介。 什么叫接口？接口，inerface，类的内外部交互函数，也可以把它视作一个数据缓冲器。 为什么要做接口？便于数据的统一管理。一个最实用的例子就是输入数据的有效性检测。 下面看一段例程： ———— PHP代码 ————[color=#000000][color=#0000bb]<?php [/color]
js 模块化代码流程
qq_24520119的博客
08-12 218
var Module = function() {   this.init(); };   // 初始化 Module.prototype.init = function() {   this.fetchData(function() {     // do something   }); };   // 绑定事
封装与方法构造
qq_45971013的博客
08-02 134
封装的好处： 1、封装之后，对于那个事物来说看不到这个事物比较复杂的那一面，只能看到该事物简单的那一面，复杂性封装，对外提供简单的操作入口。照相机就是一个很好的封装案例，照相机的实现原理非常复杂，但是对于是用照相机的人来说，操作起来是非常便捷的。...
mdk_armcc_user_guide.pdf
08-07
__attribute__是GNU C/C++编译器中的一个重要特性，它允许开发者在编译时提供额外的指令或元数据，以优化代码、提高性能或解决特定平台的兼容性问题。此文档不同于网上的零散教程，它系统地整理了__attribute__的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值