小编ant*_*009的帖子

Ubuntu 10.10 gcc 4.4.4

我只是在尝试分配和释放.

但是,当一个对象被多次释放时,我试图避免这个问题.

但是,当我测试时,我注意到创建和释放的obj没有返回到null状态.那么有什么条件我可以设置,如果这确实发生将避免？

我也试过在free之后将对象设置为NULL.但是,它仍然试图释放该对象.

这是对这个问题的引用,只是让你知道不重复: 释放已分配的内存

我的代码如下:

#include <stdio.h>
#include "objects.h"

int main(void)
{
    obj_t *obj = NULL;

    obj = create_object();

    destroy_object(obj);

    destroy_object(obj);

    return 0;
}

==

#ifndef OBJECTS_H_INCLUDED
#define OBJECTS_H_INCLUDED

typedef struct Obj_t obj_t;

obj_t* create_object();
void destroy_object(obj_t *obj);

#endif /* OBJECTS_H_INCLUDED */

==

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

#include "objects.h"

struct Obj_t {
    int obj_id;
};

obj_t* create_object()
{
    obj_t *obj = malloc(sizeof obj);

    return obj;
}

void destroy_object(obj_t *obj)
{
    if(obj != NULL) { …

gcc 4.5.1 c89

我已经编写了这个源代码,以便我更好地理解malloc和calloc.

我理解,但只是有几个问题.

dev = malloc(number * sizeof *devices);

等于这个calloc.我并不担心清理内存.

dev = calloc(number, sizeof *devices);

与在while循环中执行5次相比,这究竟是什么呢？

dev = malloc(sizeof *devices);

我想第一个和第二个是创建一个指向5结构设备的指针.第三个是创建一个指向结构设备的指针？

我的程序说明了使用valgrind编译和运行的3种不同方法--leak-check = full.

非常感谢任何建议.

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

struct Devices {
#define MAX_NAME_SIZE 80
    size_t id;
    char name[MAX_NAME_SIZE];
};

struct Devices* create_device(struct Devices *dev);
void destroy_device(struct Devices *dev);

int main(void)
{
    size_t num_devices = 5;
    size_t i = 0;
    struct Devices *device = NULL;
    struct Devices *dev_malloc = NULL;
    struct Devices *dev_calloc = NULL;

    for(i = 0; …

gcc 4.7.2
c89

你好,

我想知道是否有任何人知道任何教程或教科书,涵盖使用makefile为我的c程序创建一些简单的单元测试.

我想运行一些自动化测试,创建一个测试套件并将其添加到我的Makefile中.

只想了解如何开始的一些想法.

非常感谢任何建议

c89 gcc 4.7.4

你好,

我只是试验这些宏:

#define LOG_INFO_1(fmt, ...) printf(fmt, __VA_ARGS__)
#define LOG_INFO_2(...) printf(__VA_ARGS__)

并使用这样:

LOG_INFO_1("%s:%d", __func__, __LINE__);
LOG_INFO_2("%s:%d", __func__, __LINE__);

输出提供完全相同的格式.我只是想知道fmt在我的第一个宏中使用参数有什么好处？它似乎并不是真的需要.我怎么能利用它呢？

非常感谢任何建议,

gcc 4.7.2 c89

你好,

我有以下功能:

void module_param_destroy(module_param_t *param)
{
    param = NULL;

    /* Stop the compiler from complaining */
    APR_UNUSED(param);
}

而我这样称呼它:

module_param_destroy(module->call_param);

参数param是否设置为NULL.当我传递本地副本时,我认为它在这里没有做任何有用的事情.

这样做会更好吗:

void module_param_destroy(module_t *md)
{
    md->param = NULL;

    /* Stop the compiler from complaining */
    APR_UNUSED(md->param);
}

并称之为:

module_param_destroy(md);

这些结构从malloc全局分配了内存.

非常感谢任何建议,

gcc (GCC) 4.8.2
c89

你好,

屏蔽按位运算符:

我想掩盖以下内容:

SIGNAL_ID_EVENT_DTMF_1 | SIGNAL_ID_EVENT_DTMF_STAR | SIGNAL_ID_EVENT_DTMF_POUND

我用以下函数设置上面的内容:

static void g_convert2_ipm_digits(unsigned short *terminator)
{
    *terminator = SIGNAL_ID_EVENT_DTMF_1 | SIGNAL_ID_EVENT_DTMF_STAR | SIGNAL_ID_EVENT_DTMF_POUND;

}

因此,当一个数字进入I&(和)它以查看该模式是否存在:

static apk_bool_t g_check_term_digit(unsigned short terminators, unsigned short digit)
{
    if(terminators & digit) {
        return TRUE;
    }
    return FALSE
}

但是,无论数字是多少,函数总是返回true.只应该为我掩盖的那些返回true.

当我在上面的函数中检查调试器时,我得到以下函数.但是,这不应该返回true,因为已按下的数字是5.

(gdb) p terminators
$22 = 11
(gdb) p digit
$23 = 5

我期望的数字在下面的枚举中定义:

typedef enum
{       
        SIGNAL_ID_EVENT_DTMF_0                                               = 0x0,
        SIGNAL_ID_EVENT_DTMF_1                                               = 0x1,
        SIGNAL_ID_EVENT_DTMF_2                                               = 0x2,
        SIGNAL_ID_EVENT_DTMF_3                                               = 0x3,
        SIGNAL_ID_EVENT_DTMF_4                                               = 0x4, …

使用接口作为类型来实例化类对象有些困惑.为什么我们需要将接口作为一种类型？什么时候我们可以使用这个类？因为该类实现了接口.我知道你无法实例化一个接口.

非常感谢任何建议,

   public interface SortRecords {
        int query(int rowId);
    }

    public class OurPrice implements SortRecords {
        @Override
        public int query(int rowId) {
            return 0;
        }
    }

    public void test() {
        /* 
         * Why has the interface as the type? 
         */
        SortRecords sorterV1 = new OurPrice();
        sorterV1.query(1);

        /* 
         * Why not just do like this? 
         */
        OurPrice sorterV2 = new OurPrice();
        sorterV2.query(2);
    }

java version "1.8.0_92"

嗨,

我试图将这个使用迭代的函数转换为递归函数.

  public static String bitConversion(int x) {
        List<Integer> binaryList = new ArrayList<Integer>();

        while(x > 0) {
            binaryList.add(x % 2);
            x /= 2;
        }

        StringBuilder stringBuilder = new StringBuilder();
        for(Integer binary : binaryList) {
            stringBuilder.append(binary.toString());
        }

        return stringBuilder.toString();
    }

我的尝试是这样的

  public static String bitConversion(int x) {
        List<Integer> binaryList = new ArrayList<Integer>();

        if(x <= 0) {
            StringBuilder stringBuilder = new StringBuilder();
            for(Integer binary : binaryList) {
                stringBuilder.append(binary.toString());
            }

            return stringBuilder.toString();
        }
        else {
            binaryList.add(x % 2);
            return bitConvert(x …

Android Studio 3.0 RC2
Kolin 1.1.51

我创建了一个 Android 应用程序，我想返回扩展 Application 的类的实例，并访问与在 Java 中使用 static 所做的等效操作。

class BusbyMoviesMainApplication : Application() {
    companion object {
        private val instance: BusbyMoviesMainApplication = BusbyMoviesMainApplication()

        @JvmStatic
        fun getBusbyInstance(): BusbyMoviesMainApplication {
            return instance
        }
    }
}

我正在像这样访问它。但是，getCacheDir 返回 null

BusbyMoviesMainApplication.getBusbyInstance().getCacheDir()

我看不出我做错了什么。

在 Java 中我以前做过这样的事情，它有效，我试图在 Kotlin 中做同样的事情：

public class BusbyMoviesApplication extends Application {
    private static BusbyMoviesApplication mBusbyMoviesApplication;

    public static BusbyMoviesApplication getInstance() {
        return mBusbyMoviesApplication;
    }

    @Override
    public void onCreate() {
        super.onCreate();

        mBusbyMoviesApplication = BusbyMoviesApplication.this;
    }
}

Kotlin 1.4.21

我有一个产品列表，我想将价格转换为格式化的字符串。但是，价格不会更改为格式化的价格。

IE

orginal price: 1658

expected: "1,658.00"

actual: 1658

这是类结构

data class Product(
    val productName: String,
    val price: Double)

在这里，我正在使用我的项目列表，我想改变价格。

listOfProjects.map {
    it.price.toAmount(2) // extension function that formats to 2 decimal places and converts to a string
}

if (listOfProjects.isNotEmpty()) {
    // Do something with the list. However, the price hasn't changed
}

gcc(GCC)4.7.0 c89

我使用以下内容分配内存:

db_data_size = 32;
db->db_data[i]->name = malloc(db_data_size);

(gdb) p db_data_size
$24 = 32
(gdb) p sizeof(db->db_data[i]->name)
$25 = 8
(gdb) n
205   db->db_data[i]->email = malloc(db_data_size);
(gdb) p sizeof(db->db_data[i]->name)
$26 = 8

在调试器中,我得到8个字节而不是我认为应该分配的32个字节.

我的结构是:

struct data {
    int id;
    int set;
    char *name;
    char *email;
};

struct database {
    struct data **db_data;
    size_t database_rows;
    size_t database_data_size;
};

我能想到的唯一想法是char*是8个字节,这就是我得到的.但是,在malloc中我明确要求32个字节.

java version 1.7.0_65

我有一个单例设计模式类.这将始终返回最初创建的同一实例.

但是,我遇到的问题是这个类需要从另一个类创建许多其他对象.我已经使用了这个组合(POI类的实例ArlabFacade).从这个单例实例中,客户端应该能够创建许多POI对象.而且我不想公开POI类的内部工作,一切都必须通过单例实例.

private static ArlabFacade mArlabFacade = null;
private POI mPoi; /* Should be able to create many object of this class */

private ArlabFacade(Context context) {     
        /* initialize properties */
        mContext = context;

        mPoi = null;
    }

public static ArlabFacade getInstance(Context context) {

        /* Create a synchronised singleton instance */
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        if(mArlabFacade == null) {
            mArlabFacade = new ArlabFacade(context);
        }
        lock.unlock();

        return mArlabFacade;
    }

我尝试过做这样的事情,但它有两个问题.

1) I …