C++ class_addfloat函数代码示例

void dollarg_setup(void)
{
  dollarg_class = class_new(gensym("dollarg"), (t_newmethod)dollarg_new,
    (t_method)dollarg_free, sizeof(t_dollarg), 0, 0);
  class_addcreator((t_newmethod)dollarg_new, gensym("$n"), 0);
  class_addbang(dollarg_class, (t_method)dollarg_bang);
  class_addfloat(dollarg_class, (t_method)dollarg_float);
//  class_sethelpsymbol(dollarg_class, gensym("iemhelp/help-dollarg"));
}

void mjRose_setup(void) {
    mjRose_class = class_new(gensym("mjRose"),
    (t_newmethod)mjRose_new,
            0, sizeof(t_mjRose),
            CLASS_DEFAULT,
            A_DEFFLOAT, 0);
    class_addfloat(mjRose_class, mjRose_float);
    
}

void setup_0x400x2f(void) {
	rdiv_class = class_new(gensym("@/"),
		(t_newmethod)rdiv_new, 0,
		sizeof(t_binop), 0,
		A_DEFFLOAT, 0);
	class_addbang(rdiv_class, rdiv_bang);
	class_addfloat(rdiv_class, rdiv_float);
	class_sethelpsymbol(rdiv_class, gensym("revbinops"));
}

void flip_tilde_setup(void)
{
	sigflip_class = class_new(gensym("flip~"), (t_newmethod)sigflip_new, 0,
        sizeof(t_sigflip), 0, A_DEFFLOAT, 0);
    class_addmethod(sigflip_class, nullfn, gensym("signal"), A_NULL);
    class_addmethod(sigflip_class, (t_method)sigflip_dsp, gensym("dsp"), A_NULL);
	class_addfloat(sigflip_class, (t_method)sigflip_float);
    class_sethelpsymbol(sigflip_class, gensym("help-flip~.pd"));
}

void sleepgrain_setup(void)
{
  sleepgrain_class = class_new(gensym("sleepgrain"), (t_newmethod)sleepgrain_new, 
                                     0, sizeof(t_sleepgrain), 0, A_NULL);
  
  class_addbang  (sleepgrain_class, sleepgrain_bang);
  class_addfloat (sleepgrain_class, sleepgrain_float);
  zexy_register("sleepgrain");
}

void hz2rad_setup(void)
{
  hz2rad_class = class_new(gensym("hz2rad"), (t_newmethod)hz2rad_new,
			  (t_method)hz2rad_free,sizeof(t_hz2rad),0, A_DEFFLOAT, 0);
  class_addfloat(hz2rad_class,(t_method)hz2rad_float);
  class_addlist(hz2rad_class,(t_method)hz2rad_list);
  class_addmethod(hz2rad_class,(t_method)hz2rad_set,gensym("set"),A_DEFFLOAT,0);
  class_addbang(hz2rad_class,(t_method)hz2rad_bang);
}

void xbendin2_setup(void)
{
    xbendin2_class = class_new(gensym("xbendin2"), 
			       (t_newmethod)xbendin2_new, 0,
			       sizeof(t_xbendin2), 0,
			       A_DEFFLOAT, 0);
    class_addfloat(xbendin2_class, xbendin2_float);
    /* CHECKME autocasting lists to floats */
}

void change_setup(void)
{
    change_class = class_new(gensym("change"), (t_newmethod)change_new, 0,
        sizeof(t_change), 0, A_DEFFLOAT, 0);
    class_addbang(change_class, change_bang);
    class_addfloat(change_class, change_float);
    class_addmethod(change_class, (t_method)change_set, gensym("set"),
        A_DEFFLOAT, 0);
}

void delreadc_tilde_setup(void)
{
    sigdelreadc_class = class_new(gensym("delreadc~"),
        (t_newmethod)sigdelreadc_new, 0,
        sizeof(t_sigdelreadc), 0, A_DEFSYM, A_DEFFLOAT, 0);
    class_addmethod(sigdelreadc_class, (t_method)sigdelreadc_dsp,
        gensym("dsp"), A_CANT, 0);
    class_addfloat(sigdelreadc_class, (t_method)sigdelreadc_float);
}

void xnoteout_setup(void)
{
    xnoteout_class = class_new(gensym("xnoteout"), 
			       (t_newmethod)xnoteout_new, 0,
			       sizeof(t_xnoteout), 0,
			       A_DEFFLOAT, 0);
    class_addbang(xnoteout_class, xnoteout_dooutput);
    class_addfloat(xnoteout_class, xnoteout_float);
}

static void sigdelread_setup(void)
{
    sigdelread_class = class_new(gensym("delread~"),
        (t_newmethod)sigdelread_new, 0,
        sizeof(t_sigdelread), 0, A_DEFSYM, A_DEFFLOAT, 0);
    class_addmethod(sigdelread_class, (t_method)sigdelread_dsp,
        gensym("dsp"), 0);
    class_addfloat(sigdelread_class, (t_method)sigdelread_float);
}

void ceil_setup(void)
{
  ceil_class = class_new(gensym("ceil"), (t_newmethod)ceil_new,
			  (t_method)ceil_free,sizeof(t_ceil), 0, 0);
  class_addfloat(ceil_class,(t_method)ceil_float);
  class_addlist(ceil_class,(t_method)ceil_list);
  class_addmethod(ceil_class,(t_method)ceil_set,gensym("set"),A_DEFFLOAT,0);
  class_addbang(ceil_class,(t_method)ceil_bang);
}

static void bag_setup(void)
{
    bag_class = class_new(gensym("bag"),
        (t_newmethod)bag_new, (t_method)bag_clear,
        sizeof(t_bag), 0, 0);
    class_addfloat(bag_class, bag_float);
    class_addmethod(bag_class, (t_method)bag_flush, gensym("flush"), 0);
    class_addmethod(bag_class, (t_method)bag_clear, gensym("clear"), 0);
}

void maximum_setup(void)
{
    maximum_class = class_new(gensym("maximum"),
			      (t_newmethod)maximum_new, (t_method)maximum_free,
			      sizeof(t_maximum), 0, A_DEFFLOAT, 0);
    class_addbang(maximum_class, maximum_bang);
    class_addfloat(maximum_class, maximum_float);
    class_addlist(maximum_class, maximum_list);
}

static void poly_setup(void)
{
    poly_class = class_new(gensym("poly"),
        (t_newmethod)poly_new, (t_method)poly_free,
        sizeof(t_poly), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
    class_addfloat(poly_class, poly_float);
    class_addmethod(poly_class, (t_method)poly_stop, gensym("stop"), 0);
    class_addmethod(poly_class, (t_method)poly_clear, gensym("clear"), 0);
}