精华内容
下载资源
问答
  • brew reference brew reference brew reference
  • reference中的reference中的reference中的reference中的
  • css reference

    2016-04-26 19:38:39
    my css reference my css reference my css reference.
  • dataguard reference

    2011-03-14 20:29:28
    dataguard reference dataguard reference dataguard reference
  • networkx_reference

    2019-04-07 11:34:31
    networkx_reference networkx_reference
  • hibernate_reference

    2018-04-08 14:11:23
    hibernate_reference hibernate_reference hibernate_reference
  • Kotlin Unresolved reference: 解决办法

    万次阅读 热门讨论 2018-01-05 16:42:20
    kotlin Unresolved reference:错误的解决办法

    Android官方已经不建议使用Kotlin Android Extensions 了,建议使用ViewBinding代替Kotlin synthetics,详情请看:

    ViewBinding代替Kotlin synthetics


    已下是之前使用 Kotlin synthetics 遇到的问题

    今天在使用Kotlin写demo的时候发现,当我在主工程中的xml布局中通过include标签引入其他Moudle中的布局后,编译就会报Unresolved reference xxx这个错误.但是include本模块中的布局就没问题。应该是目前kotlin-android-extensions暂时还不支持跨模块的问题吧。(截止到2018-01-05)

    解决办法:
    1.将通用布局放到本模块中
    2.直接在xml中写布局,不要include其他模块中的布局

    暂时只想到这两个笨方法,如果你有更好的解决方法,还请指教。不胜感激,谢谢!


    展开全文
  • OpenGL Reference Manual OpenGL Reference Manual
  • spring boot reference doc

    2017-11-03 08:22:15
    spring boot reference spring boot reference spring boot reference
  • 在实际编译代码的过程中,我们经常会遇到"undefined reference to"的问题,简单的可以轻易地解决,但有些却隐藏得很深,需要花费大量的时间去排查。工作中遇到了各色各样类似的问题,按照以下几

    在实际编译代码的过程中,我们经常会遇到"undefined reference to"的问题,简单的可以轻易地解决,但有些却隐藏得很深,需要花费大量的时间去排查。工作中遇到了各色各样类似的问题,按照以下几种可能出现的状况去排查,可有利于理清头绪,从而迅速解决问题。

    链接时缺失了相关目标文件

    首先编写如下的测试代码:

    
    // test.h
    
    #ifndef __TEST_H__
    #define __TEST_H__
    
    void test();
    
    #endif
    
    // test.c
    
    #include <string.h>
    #include <stdio.h>
    
    
    
    void test()
    {
        printf("just test it\n");
    }
    
    // main.c
    
    #include "test.h"
    
    int main(int argc, char **argv)
    {
        test();
    
        return 0;
    }

    通过以下的命令,我们将会得到两个.o文件。

    $ gcc -c test.c  
    $ gcc –c main.c 

    随后,我们将main.o这个文件,编译成可执行文件。

    $ gcc -o main main.o
    Undefined symbols for architecture x86_64:
      "_test", referenced from:
          _main in main.o
    ld: symbol(s) not found for architecture x86_64
    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    编译时报错了,这是最典型的undefined reference错误,因为在链接时发现找不到某个函数的实现文件。如果按下面这种方式链接就正确了。

    $ gcc -o main main.o test.o

    当然,也可以按照如下的命令编译,这样就可以一步到位。

    $ gcc -o main main.c test.c

    链接时缺少相关的库文件

    我们把第一个示例中的test.c编译成静态库。

    $ gcc -c test.c  
    $ ar -rc test.a test.o 

    接着编译可执行文件,使用如下命令:

    $ gcc -o main main.c 
    Undefined symbols for architecture x86_64:
      "_test", referenced from:
          _main in main-6ac26d.o
    ld: symbol(s) not found for architecture x86_64
    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    其根本原因也是找不到test()函数的实现文件,由于test()函数的实现在test.a这个静态库中,故在链接的时候需要在其后加入test.a这个库,链接命令修改为如下形式即可。

    $ gcc -o main main.c test.a

    链接的库文件中又使用了另一个库文件  (这个例子非常非常好, 我就是犯了这种错误!!!)

    先更改一下第一个示例中使用到的代码,在test()中调用其它的函数,更改的代码如下所示。

    
    // func.h
    
    #ifndef __FUNC_H__
    #define __FUNC_H__
    
    void func();
    
    #endif
    
    // func.c
    
    #include <stdio.h>
    
    void func()
    {
        printf("call it\n");
    }
    
    // test.h
    
    #ifndef __TEST_H__
    #define __TEST_H__
    
    void test();
    
    #endif
    
    // test.c
    
    #include <string.h>
    #include <stdio.h>
    
    #include "func.h"
    
    
    
    void test()
    {
        printf("just test it\n");
    
        func();
    }
    
    // main.c
    
    #include "test.h"
    
    int main(int argc, char **argv)
    {
        test();
    
        return 0;
    }

    我们先对fun.ctest.c进行编译,生成.o文件。

    $ gcc -c func.c  
    $ gcc -c test.c

    然后,将test.cfunc.c各自打包成为静态库文件。

    $ ar –rc func.a func.o  
    $ ar –rc test.a test.o 

    这时将main.c编译为可执行程序,由于main.c中包含了对test()的调用,因此,应该在链接时将test.a作为我们的库文件,链接命令如下。

    $ gcc -o main main.c test.a
    Undefined symbols for architecture x86_64:
      "_func", referenced from:
          _test in test.a(test.o)
    ld: symbol(s) not found for architecture x86_64
    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    就是说,链接的时候发现test.a调用了func()函数,找不到对应的实现,我们还需要将test.a所引用到的库文件也加进来才能成功链接,因此命令如下。

    $ gcc -o main main.c test.a func.a

    同样,如果我们的库或者程序中引用了第三方库(如pthread.a)则在链接的时候需要给出第三方库的路径和库文件,否则就会得到undefined reference的错误。

    多个库文件链接顺序问题

    这种问题非常隐蔽,不仔细研究,可能会感到非常地莫名其妙。以第三个示例为测试代码,把链接库的顺序换一下,如下所示:

    $ gcc -o main main.c func.a test.a
    test.a(test.o): In function `test':  
    test.c:(.text+0x13): undefined reference to `func'  
    collect2: ld returned 1 exit status

    因此,在链接命令中给出所依赖的库时,需要注意库之间的依赖顺序,依赖其他库的库一定要放到被依赖库的前面,这样才能真正避免undefined reference的错误,完成编译链接。

    备注:在MAC上可以正常编译通过。

    定义与实现不一致

    编写测试代码如下:

    
    // test.h
    
    #ifndef __TEST_H__
    #define __TEST_H__
    
    void test(unsigned int c);
    
    #endif
    
    // test.c
    
    #include <string.h>
    #include <stdio.h>
    
    
    
    void test(int c)
    {
        printf("just test it\n");
    }
    
    // main.c
    
    #include "test.h"
    
    int main(int argc, char **argv)
    {
        test(5);
    
        return 0;
    }

    先将test.c编译成库文件。

    $ gcc -c test.c 
    $ ar -rc test.a test.o

    main.c编译成可执行文件。

    $ gcc -o main main.c test.a
    ld: warning: ignoring file test.a, file was built for archive which is not the architecture being linked (x86_64): test.a
    Undefined symbols for architecture x86_64:
      "_test", referenced from:
          _main in main-f27cf1.o
    ld: symbol(s) not found for architecture x86_64
    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    链接出错了,原因很简单,test()这个函数的声明和定义不一致导致,将两者更改成一样即可通过编译。

    c++代码中链接c语言的库

    代码同示例一的代码一样,只是把main.c更改成了main.cpp。编译test.c,并打包为静态库。

    $ gcc -c test.c  
    $ ar -rc test.a test.o

    编译可执行文件,用如下命令:

    $ g++ -o main main.cpp test.a 
    Undefined symbols for architecture x86_64:
      "test()", referenced from:
          _main in main-7d7fde.o
    ld: symbol(s) not found for architecture x86_64
    clang: error: linker command failed with exit code 1 (use -v to see invocation)

    原因就是main.cppc++代码,调用了c语言库的函数,因此链接的时候找不到,解决方法是在相关文件添加一个extern "C"的声明即可,例如修改test.h文件。

    
    // test.h
    
    #ifndef __TEST_H__
    #define __TEST_H__
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    void test();
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif

    展开全文
  • Deep Learning Toolbox Reference, Deep Learning Toolbox Reference, Deep Learning Toolbox Reference
  • spring framework reference htmlsingle(单机英文版reference)4.3.8.RELEASE
  • Verilog Reference

    2010-03-02 14:51:34
    Verilog Quick Reference
  • MySQL 5.6 Reference Manual

    2018-05-07 14:11:25
    MySQL 5.6 Reference Manual Including MySQL NDB Cluster 7.3-7.4 Reference Guide
  • 描述:模块部分,写一个外部模块导入的时候居然提示unresolved reference,如下,程序可以正常运行,但是就是提示包部分红色,看着特别不美观,下面是解决办法 PyCharm版本: 解决: 1.在项目上 单击右键 -&...

    描述:模块部分,写一个外部模块导入的时候居然提示unresolved reference,如下,程序可以正常运行,但是就是提示包部分红色,看着特别不美观,下面是解决办法

    PyCharm版本:

    解决:

        1.在项目上 单击右键 -> Mark Directory as -> Sources Root

        2.点击之后红色警告消失

        3.进入设置:file -> settings

        4.按照下图展开 Build,Execution,Deployment -> Console -> Python Console -> Add source roots to PYTHONPATH,勾选上3,选择确定,问题完美解决

    5.如果问题还没解决,欢迎大家留言探讨

    网友留言提示:如果创建的是directory而不是package上述操作不会生效!

    【已经多次掉入这个坑了,大家网上查,很多说设置成source root就可以了,然后添加路径,有的可以解决,有的不能解决,这是为什么了,经过多次尝试发现,我们忽略了一个问题,就是有的小伙伴新建文件夹而不是包(图标上有小圆圈),如果这种情况采取以上操作无效的,需要把文件夹转成包】

    展开全文
  • Dubbo之@ReferenceReferenceBean

    千次阅读 2019-07-17 12:41:49
    1、构建一个ReferenceBean,然后使用Spring的@Autowired引用服务 @Bean public ReferenceBean<PLRepaymentPlanService> repaymentPlanServiceReferenceBean(){ ReferenceBean<PLRepayment...

    consumer调用dubbo服务

    两种方法:

    1、构建一个ReferenceBean,然后使用Spring的@Autowired引用服务

    @Bean
    public ReferenceBean<PLRepaymentPlanService> repaymentPlanServiceReferenceBean(){
        ReferenceBean<PLRepaymentPlanService> referenceBean = new ReferenceBean<>();
        referenceBean.setInterface(PLRepaymentPlanService.class);
        referenceBean.setCheck(false);
        referenceBean.setValidation("true");
        return referenceBean;
    }
    @Autowired
    private PLRepaymentPlanService plRepaymentPlanService;

    2、使用dubbo的@Reference注解

    @Reference
    ExampleService exampleService

    @Reference其实就是将引用的服务 构建成一个ReferenceBean然后在调用 原理一样 

    以下资料参考:https://blog.csdn.net/u012394095/article/details/83142193 

    源码入口
    com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar

    Override
      public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      // 获取扫描包路径
      Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
      // 注册@service解析的类
      registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
      // 注册解析@Reference注解的bean
      registerReferenceAnnotationBeanPostProcessor(registry);

    }



    registerReferenceAnnotationBeanPostProcessor

     

    private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) {

            // Register @Reference Annotation Bean Processor
            BeanRegistrar.registerInfrastructureBean(registry,
                    ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);

    }

    调用了BeanRegistrar工具类来注册Reference解析器的BeanDefinition, registerInfrastructureBean方法的主要作用就是将ReferenceAnnotationBeanPostProcessor这个类注册到BeanDefinition

    public class BeanRegistrar {

        /**
         * Register Infrastructure Bean
         *
         * @param beanDefinitionRegistry {@link BeanDefinitionRegistry}
         * @param beanType               the type of bean
         * @param beanName               the name of bean
         */
        public static void registerInfrastructureBean(BeanDefinitionRegistry beanDefinitionRegistry,
                                                      String beanName,
                                                      Class<?> beanType) {

            if (!beanDefinitionRegistry.containsBeanDefinition(beanName)) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
                beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                  // 注册
                beanDefinitionRegistry.registerBeanDefinition(beanName, beanDefinition);
            }

        }

    }


    ReferenceAnnotationBeanPostProcessor


    本文的重点在于ReferenceAnnotationBeanPostProcessor类,该类继承了InstantiationAwareBeanPostProcessor ,用来解析@Reference注解并完成依赖注入。

    public class ReferenceAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
            implements MergedBeanDefinitionPostProcessor, PriorityOrdered, ApplicationContextAware, BeanClassLoaderAware,
            DisposableBean {
        // 省略注解
    }

    **InstantiationAwareBeanPostProcessor **:实例化Bean后置处理器(继承BeanPostProcessor)

    1.postProcessBeforeInstantiation :在实例化目标对象之前执行,可以自定义实例化逻辑,如返回一个代理对象等。

    2.postProcessAfterInitialization : Bean实例化完毕后执行的后处理操作,所有初始化逻辑、装配逻辑之前执行,如果返回false将阻止其他的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation的执行。

    3.postProcessPropertyValues :完成其他定制的一些依赖注入和依赖检查等,如AutowiredAnnotationBeanPostProcessor执行@Autowired注解注入,CommonAnnotationBeanPostProcessor执行@Resource等注解的注入,PersistenceAnnotationBeanPostProcessor执行@ PersistenceContext等JPA注解的注入,RequiredAnnotationBeanPostProcessor执行@ Required注解的检查等等。

    dubbo也是采用了和@Autowired注入一样的原理,通过继承InstantiationAwareBeanPostProcessor 重写postProcessPropertyValues 方法来达到解析@Reference并实现依赖注入。

    @Override
    public PropertyValues postProcessPropertyValues(
      PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
      //这个是注入元数据,包含了目标Bean的Class对象,和注入元素(InjectionElement)集合
      InjectionMetadata metadata = findReferenceMetadata(beanName, bean.getClass(), pvs);
      try {
         // 通过反射来给bean设置值了
        metadata.inject(bean, beanName, pvs);
      } catch (BeanCreationException ex) {
        throw ex;
      } catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of @Reference dependencies failed", ex);
      }
      return pvs;
    }


    通过findReferenceMetadata找到@Reference,并解析得到元数据对象,最终实现依赖注入,@Autowired注解也是这个干的,二者的实现原理是一模一样。

    private InjectionMetadata findReferenceMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
            // 通过类名作为缓存的key
            String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
            // 从缓存中的injectionMetadataCache根据类名获取元数据
            ReferenceInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
              // 判断metadata 是否为空,  class对象不等于ReferenceInjectionMetadata , 则需要进行刷新
            if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                synchronized (this.injectionMetadataCache) {
                      // 双重检查机制
                    metadata = this.injectionMetadataCache.get(cacheKey);
                    if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                        if (metadata != null) {
                            metadata.clear(pvs);
                        }
                        try {
                              // 构建InjectionMetadata元数据
                            metadata = buildReferenceMetadata(clazz);
                            this.injectionMetadataCache.put(cacheKey, metadata);
                        } catch (NoClassDefFoundError err) {
                            throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() +
                                    "] for reference metadata: could not find class that it depends on", err);
                        }
                    }
                }
            }
            return metadata;
        }
     


    buildReferenceMetadata

     

    private ReferenceInjectionMetadata buildReferenceMetadata(final Class<?> beanClass) {
              // 获取属性上的@Reference注解
            Collection<ReferenceFieldElement> fieldElements = findFieldReferenceMetadata(beanClass);
              // 获取方法上的@Reference注解
            Collection<ReferenceMethodElement> methodElements = findMethodReferenceMetadata(beanClass);
            return new ReferenceInjectionMetadata(beanClass, fieldElements, methodElements);

    }

    获取属性上的@Reference注解findFieldReferenceMetadata

    private List<ReferenceFieldElement> findFieldReferenceMetadata(final Class<?> beanClass) {
        
            final List<ReferenceFieldElement> elements = new LinkedList<ReferenceFieldElement>();
            // 通过反射的工具类,获取当前beanClass的所有Filed
            ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() {
                @Override
                public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                    // 获取Reference注解
                    Reference reference = getAnnotation(field, Reference.class);
                    // 注解不为空
                    if (reference != null) {

                        if (Modifier.isStatic(field.getModifiers())) {
                            if (logger.isWarnEnabled()) {
                                logger.warn("@Reference annotation is not supported on static fields: " + field);
                            }
                            return;
                        }
                        // 构建ReferenceFieldElement
                        elements.add(new ReferenceFieldElement(field, reference));
                    }

                }
            });

            return elements;

        }

    上面的代码就很简单了,通过ReflectionUtils工具类,反射获取当前beanClass 的所有Filed , 之后获取每个filed上的@Reference注解,如果获取不为空,则继续下一步。最终构建ReferenceFieldElement对象,将对应的filed和Reference注解放进去。

    元数据收集好了,接下来就是调用metadata.inject(bean, beanName, pvs);这个方法了。

    public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
              // 获取InjectedElement
            Collection<InjectionMetadata.InjectedElement> elementsToIterate = this.checkedElements != null ? this.checkedElements : this.injectedElements;
            if (!((Collection)elementsToIterate).isEmpty()) {
                boolean debug = logger.isDebugEnabled();
                // 进行循环,也就是循环设值,因为有多个字段嘛。
                InjectionMetadata.InjectedElement element;
                for(Iterator var6 = ((Collection)elementsToIterate).iterator(); var6.hasNext(); element.inject(target, beanName, pvs)) {
                    element = (InjectionMetadata.InjectedElement)var6.next();
                    if (debug) {
                        logger.debug("Processing injected element of bean '" + beanName + "': " + element);
                    }
                }
            }

        }

    上面的代码,其实只有一行,那就是element.inject(target, beanName, pvs) 这一行,因为一个InjectedElement对象就表示一个字段对象,这个对象中将字段信息和注解信息绑定在了一起,调用inject方法就是为了给这个filed进行赋值。

     

    ###ReferenceFieldElement

     

    private class ReferenceFieldElement extends InjectionMetadata.InjectedElement {
            // 字段对象
            private final Field field;
            // Reference注解对象
            private final Reference reference;
            // 服务引用对象
            private volatile ReferenceBean<?> referenceBean;

            protected ReferenceFieldElement(Field field, Reference reference) {
                super(field, null);
                this.field = field;
                this.reference = reference;
            }

            @Override
            protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
                // 获取字段的类型
                Class<?> referenceClass = field.getType();
                // 构建ReferenceBean
                referenceBean = buildReferenceBean(reference, referenceClass);
                // 字段为私有,需要设置这个属性field.setAccessible(true)  才能进行设值
                ReflectionUtils.makeAccessible(field);
                // 给这个对象bean的这个filed设置值,值为:referenceBean.getObject()
                field.set(bean, referenceBean.getObject());

            }

        }

    通过buildReferenceBean方法创建服务引用对象

    private ReferenceBean<?> buildReferenceBean(Reference reference, Class<?> referenceClass) throws Exception {
            // 获取服务引用对象的缓存key
            String referenceBeanCacheKey = generateReferenceBeanCacheKey(reference, referenceClass);
            // 从缓存map中获取服务引用对象
            ReferenceBean<?> referenceBean = referenceBeansCache.get(referenceBeanCacheKey);

            if (referenceBean == null) {
                // 如果引用对象为空,则需要当场创建一个
                ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
                        .create(reference, classLoader, applicationContext)
                        .interfaceClass(referenceClass);

                referenceBean = beanBuilder.build();
                //并且放入到缓存map中。
                referenceBeansCache.putIfAbsent(referenceBeanCacheKey, referenceBean);

            }

            return referenceBean;

        }
     private String generateReferenceBeanCacheKey(Reference reference, Class<?> beanClass) {
            // 获取接口名称
            String interfaceName = resolveInterfaceName(reference, beanClass);
            // 通过引用的URl+接口名+接口版本号+接口分组,用来做缓存key
            String key = reference.url() + "/" + interfaceName +
                    "/" + reference.version() +
                    "/" + reference.group();

            Environment environment = applicationContext.getEnvironment();

            key = environment.resolvePlaceholders(key);

            return key;

        }

    消费者每引用的一种服务,都会创建一个ReferenceBean, 如果多个地方使用@Reference引用同一个服务,需要看他们的的缓存key是否一样,如果都是一样的,那么就只会创建一个ReferenceBean,如果有些配置不一样,比如版本号不一致,则会创建创建不同的ReferenceBean对象,这也是他版本号能够起到的作用把。至此,@Reference注解已经解析完毕,并且服务引用的对象也已经创建了。

    展开全文
  • C Reference Manual.pdf

    2019-08-04 13:35:20
    C Reference Manual,C Reference Manual,C Reference Manual,C Reference Manual
  • Lettuce Reference Guide.zip

    2020-01-15 11:59:55
    Lettuce Reference Guide.zip Lettuce Reference Guide.zip Lettuce Reference Guide.zip Lettuce Reference Guide.zip
  • c++reference

    2012-11-30 11:50:21
    C++reference是一本值得你去读的书,学习C++应该读一下
  • UNIX The Complete Reference

    2016-05-21 10:41:43
    UNIX The Complete Reference
  • 主要介绍了Java 中 Reference用法详解的相关资料,需要的朋友可以参考下
  • ARM Architecture Reference Manual、ARMv7-M Architecture Reference Manual、《ARM+Architecture+Reference+Manual》中文版.pdf
  • xml api reference

    2011-07-06 16:38:53
    xml api reference,xml api reference,,xml api reference
  • 如果使用QtCreator创建类时,没有选择继承自QObject类或其子类,而在创建后手工修改继承自QObject并手工添加Q_OBJECT宏,则在编译时有可能会出现”undefined reference to `vtable for’…….”错误.解决方法: 把新创建...
  • lte network reference

    2014-03-31 12:57:38
    lte network reference mme s-gw p-gw
  • pycharm中出现unresolved reference的解决办法

    万次阅读 多人点赞 2019-03-04 10:45:22
    unresolved reference",我就很郁闷,明明代码可以正确运行的啊,怎么会出现这种错误。 红色错误提示看着真心不爽,索性去网上百度了一圈,居然没找到解决办法,后来在stackoverflow上看到有人遇到同样...
  • pdf应用开发过程中的学习资料,包括pdf reference 1.7英文版(包含自己的阅读理解注释),pdf reference 1.6中文版,xfa简介,pdfSpy软件
  • C Quick Syntax Reference

    2018-11-16 16:14:02
    The C Quick Syntax Reference is a condensed code and syntax reference to the popular C programming language, which has enjoyed some resurgence of late. This book presents the essential C syntax in a ...
  • Java Reference

    千次阅读 2015-06-11 20:26:29
    Java Reference简要笔记。。。
  • "undefined reference to" 问题解决方法

    万次阅读 多人点赞 2019-05-30 21:01:00
    (.text+0x13): undefined reference to `func’ 关于undefined reference 这样的问题,大家其实经常会遇到,在此,我以详细地示例给出常见错误的各种原因以及解决方法,希望对初学者有所帮助。 1. 链接时缺失了相关...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 766,197
精华内容 306,478
关键字:

reference