C++11新特性:让编程更便捷

需积分: 3 1 下载量 191 浏览量 更新于2024-07-19 收藏 1.27MB PDF 举报
"cpp11_Make_life_easier.pdf - C++11让编程更便捷" 在C++11标准中,引入了许多新特性,极大地提高了C++的可读性、可维护性和效率,使得程序员的生活变得更加轻松。这篇文档主要探讨了C++11中的几个关键特性,包括可变参数模板、函数对象绑定、Lambda表达式以及函数缓存,并展示了如何利用这些特性解决实际问题,尤其是简化重复代码。 1. 可变参数模板 在C++11之前,处理可变数量的参数通常需要借助于宏或者一些技巧来实现。C++11引入的可变参数模板允许我们创建接受任意数量参数的模板函数。例如,`std::tuple`的`std::tie`函数就是利用这个特性将多个变量打包成一个元组。在文档中,`B`和`A`结构体展示了如何使用`std::tie`来获取成员变量的元组,而`META`宏进一步抽象了这一过程,实现了泛型的方法来获取所有成员变量。 2. 函数对象绑定 `std::bind`是C++11中的另一个重要工具,它可以将函数或成员函数与指定的对象或参数预先绑定,创建出新的可调用对象。这在处理回调函数、事件处理等场景中非常有用。文档虽然没有详细展开,但可以想象,`std::bind`可以帮助我们创建更灵活、更易于管理的代码。 3. Lambda表达式 C++11的Lambda表达式为匿名函数提供了简洁的语法,使得在需要的地方定义和使用函数更加方便。它们常用于函数式编程、排序、过滤等操作。文档中虽然没有直接展示Lambda的例子,但Lambda表达式经常与`std::bind`一起使用,提供了一种直接在原地定义行为的方式,避免了额外的函数对象类。 4. 神奇的函数缓存 函数缓存(也称为 memoization)是一种优化技术,用于存储先前计算的结果,以减少重复计算。虽然文档没有给出具体的实现,但通常可以使用`std::unordered_map`或`std::map`来存储函数的输入和输出,从而提高性能。对于那些计算密集型但结果不随时间变化的函数,函数缓存可以大大提高效率。 完整代码可以在提供的GitHub链接中找到,这包括了`function_traits`模板,它用于获取成员函数的参数类型列表,这对于函数对象绑定和Lambda表达式的元编程操作很有帮助。 C++11通过引入这些特性,显著提升了C++的现代性和实用性,使得编写C++代码更加简洁高效。这些新特性鼓励程序员采用更面向对象和函数式编程的思维方式,降低了代码的复杂性,提高了代码质量。

优化这段代码:def calTravelCost(route_list,model): timetable_list=[] distance_of_routes=0 time_of_routes=0 obj=0 for route in route_list: timetable=[] vehicle=model.vehicle_dict[route[0]] travel_distance=0 travel_time=0 v_type = route[0] free_speed=vehicle.free_speed fixed_cost=vehicle.fixed_cost variable_cost=vehicle.variable_cost for i in range(len(route)): if i == 0: next_node_id=route[i+1] travel_time_between_nodes=model.distance_matrix[v_type,next_node_id]/free_speed departure=max(0,model.demand_dict[next_node_id].start_time-travel_time_between_nodes) timetable.append((int(departure),int(departure))) elif 1<= i <= len(route)-2: last_node_id=route[i-1] current_node_id=route[i] current_node = model.demand_dict[current_node_id] travel_time_between_nodes=model.distance_matrix[last_node_id,current_node_id]/free_speed arrival=max(timetable[-1][1]+travel_time_between_nodes,current_node.start_time) departure=arrival+current_node.service_time timetable.append((int(arrival),int(departure))) travel_distance += model.distance_matrix[last_node_id, current_node_id] travel_time += model.distance_matrix[last_node_id, current_node_id]/free_speed+\ + max(current_node.start_time - arrival, 0) else: last_node_id = route[i - 1] travel_time_between_nodes = model.distance_matrix[last_node_id,v_type]/free_speed departure = timetable[-1][1]+travel_time_between_nodes timetable.append((int(departure),int(departure))) travel_distance += model.distance_matrix[last_node_id,v_type] travel_time += model.distance_matrix[last_node_id,v_type]/free_speed distance_of_routes+=travel_distance time_of_routes+=travel_time if model.opt_type==0: obj+=fixed_cost+travel_distance*variable_cost else: obj += fixed_cost + travel_time *variable_cost timetable_list.append(timetable) return timetable_list,time_of_routes,distance_of_routes,obj

2023-06-11 上传

解释一下这段代码function [params, bg_area, fg_area, area_resize_factor] = initializeAllAreas(im, params) % we want a regular frame surrounding the object avg_dim = sum(params.target_sz)/2; % size from which we extract features bg_area = round(params.target_sz + avg_dim); % pick a "safe" region smaller than bbox to avoid mislabeling fg_area = round(params.target_sz - avg_dim * params.inner_padding); % saturate to image size if(bg_area(2)>size(im,2)), bg_area(2)=size(im,2)-1; end if(bg_area(1)>size(im,1)), bg_area(1)=size(im,1)-1; end % make sure the differences are a multiple of 2 (makes things easier later in color histograms) bg_area = bg_area - mod(bg_area - params.target_sz, 2); fg_area = fg_area + mod(bg_area - fg_area, 2); % Compute the rectangle with (or close to) params.fixedArea and % same aspect ratio as the target bbox area_resize_factor = sqrt(params.fixed_area/prod(bg_area)); params.norm_bg_area = round(bg_area * area_resize_factor); % Correlation Filter (HOG) feature space % It smaller that the norm bg area if HOG cell size is > 1 params.cf_response_size = floor(params.norm_bg_area / params.hog_cell_size); % given the norm BG area, which is the corresponding target w and h? norm_target_sz_w = 0.75*params.norm_bg_area(2) - 0.25*params.norm_bg_area(1); norm_target_sz_h = 0.75*params.norm_bg_area(1) - 0.25*params.norm_bg_area(2); % norm_target_sz_w = params.target_sz(2) * params.norm_bg_area(2) / bg_area(2); % norm_target_sz_h = params.target_sz(1) * params.norm_bg_area(1) / bg_area(1); params.norm_target_sz = round([norm_target_sz_h norm_target_sz_w]); % distance (on one side) between target and bg area norm_pad = floor((params.norm_bg_area - params.norm_target_sz) / 2); radius = min(norm_pad); % norm_delta_area is the number of rectangles that are considered. % it is the "sampling space" and the dimension of the final merged resposne % it is squared to not privilege any particular direction params.norm_delta_area = (2*radius+1) * [1, 1]; % Rectangle in which the integral images are computed. % Grid of rectangles ( each of size norm_target_sz) has size norm_delta_area. params.norm_pwp_search_area = params.norm_target_sz + params.norm_delta_area - 1; end

2023-05-31 上传

帮我改进一这段代码import machine import time from machine import I2C from machine import Pin from machine import sleep class accel(): def __init__(self, i2c, addr=0x68): self.iic = i2c self.addr = addr self.iic.start() self.iic.writeto(self.addr, bytearray([107, 0])) self.iic.stop() def get_raw_values(self): self.iic.start() a = self.iic.readfrom_mem(self.addr, 0x3B, 14) self.iic.stop() return a def get_ints(self): b = self.get_raw_values() c = [] for i in b: c.append(i) return c def bytes_toint(self, firstbyte, secondbyte): if not firstbyte & 0x80: return firstbyte << 8 | secondbyte return - (((firstbyte ^ 255) << 8) | (secondbyte ^ 255) + 1) def get_values(self): raw_ints = self.get_raw_values() vals = {} vals["AcX"] = self.bytes_toint(raw_ints[0], raw_ints[1]) vals["AcY"] = self.bytes_toint(raw_ints[2], raw_ints[3]) vals["AcZ"] = self.bytes_toint(raw_ints[4], raw_ints[5]) vals["Tmp"] = self.bytes_toint(raw_ints[6], raw_ints[7]) / 340.00 + 36.53 vals["GyX"] = self.bytes_toint(raw_ints[8], raw_ints[9]) vals["GyY"] = self.bytes_toint(raw_ints[10], raw_ints[11]) vals["GyZ"] = self.bytes_toint(raw_ints[12], raw_ints[13]) return vals # returned in range of Int16 # -32768 to 32767 def val_test(self): # ONLY FOR TESTING! Also, fast reading sometimes crashes IIC from time import sleep while 1: print(self.get_values()) sleep(0.05) clk = Pin(("clk", 36), Pin.OUT_OD) sda = Pin(("sda", 37), Pin.OUT_OD) i2c = I2C(-1, clk, sda, freq=100000) #initializing the I2C method for ESP32 #i2c = I2C(scl=Pin(5), sda=Pin(4)) #initializing the I2C method for ESP8266 mpu= accel(i2c) while True: mpu.get_values() print(mpu.get_values()) time.sleep(2)

2023-05-30 上传