dontpanic

Deveria ser note.setWifi() em vez de apenas setWifi().

Crie uma classe chamada Comodo, com comprimento e largura (e se quiser facilitar as coisas, já coloca a área dela também):
No construtor dela, você já cuida de vez desses 3 atributos:
 
 

public class Comodo {    private float comprimento;    private float largura;    private float area;     public Comodo(float comp, float larg) {        this.comprimento = comp;        this.largura = larg;        this.area = comp * larg;    }     public float getArea() {        return area;    }} Agora no teu programa principal cria um ArrayList de comodos, depois um loop perguntando se o usuário gostaria de adicionar um comodo, sempre que ele disser sim, você cria uma nova instancia da classe Comodo. Quando ele finalmente disser 'não', você calcula a área dos comodos que criou.
 
 

import java.util.ArrayList;...ArrayList<Comodo> comodos = new ArrayList<Comodo>(); Scanner entrada = new Scanner(System.in);float larg, comp;float areaTotal = 0.0; do {    // aqui pega a largura que o usuário digitar e guarda em larg    // aqui pega o comprimento que o usuário digitar e guard em comp    comodos.add(new Comodo(larg, comp));     System.out.println("Deseja adicionar um novo comodo? S/N ");} while (entrada.next().equals("S"));   // agora soma as áreas dos comodosfor (int i=0; i < comodos.size(); i++) {    areaTotal = areaTotal + comodos.get(i).getArea();}...Não testei o código acima.É só pra dar uma ideia mesmo.

Uma lista encadeada normal tem cada elemento dela apontanto pro próximo elemento, como aqui:
 

struct N { Info info; // Parte de dados PNodo proximo; // Ponteiro para o próximo. Poderia ser: struct N *proximo;};Ou seja, você "caminha" por ela apenas em uma direção. Cada elemento da lista só enxerga o elemento seguinte:[inicio] --> [Elemento1] --> [Elemento2] --> [Fim]
Na lista duplamente encadeada cada elemento dela enxerga o próximo elemento e o anterior. Você pode caminhar por ela nas duas direções:
[inicio] <--> [Elemento1] <--> [Elemento2] <--> [Fim]
 

struct N { Info info; // Parte de dados PNodo proximo; // Ponteiro para o próximo. Poderia ser: struct N *proximo; PNodo anterior;};Então em cada uma daquelas operações, de inserção e exclusão de nodos, você precisa agora setar não só a variável 'proximo' como também a variável 'anterior'.

A função vetores não tá retornando  nada, apesar de ser do tipo float.
 
Quanto as variáveis 'vet' e 'quantEleme', precisa-se entender uma coisa.
 
int x; ---> isso é uma variável que retorna um valor int
int *x; ---> isso é um ponteiro que retorna um valor int que vai ser armazenado na memória
&x ---> isso é o endereço de uma variável x
*(&x) ---> isso é um ponteiro que retorna um valor que está no endereço de x, ou seja, é a mesma coisa que escrever apenas 'x'
&(*x) --> isso é o endereço da posição na memória pra onde aquele ponteiro está apontando, ou seja, mesma coisa que escrever apenas 'x' também.
 
Daí aí vai o teu código corrigido:
 
#include <stdio.h>#include <stdlib.h>#include <string.h>void vetores(float**, int*);int main() { int i=0; int quantEleme = 0; float *vet = NULL; vetores(&vet, &quantEleme); printf("%d \n", quantEleme); for (i=0; i<quantEleme; i++) { printf("_ %f \n", vet[i]); } free(vet); return 0;}void vetores(float* *vet, int* quantEleme) { int i; printf("Digite a quantidade de valores do vetor:\n"); scanf("%d", quantEleme); if ( (*vet = malloc((*quantEleme) * sizeof(float)) ) == NULL){ printf("Memória insuficiente"); *quantEleme = 0; return; } printf("Informe os valores:\n"); for (i=0; i < *quantEleme; i++){ printf("Informe o %d valor: ", i); scanf("%f", &(*vet)[i]); }} Note que a variável 'quantEleme' deixou de ser um ponteiro e passou a ser apenas uma int normal, pois como o espaço dela na memória é fixo (ela vai guardar apenas um valor por vez), você pode declarar ela normalmente como int e passar ela pra outras funções por referência (usando o '&').

Na função 'vetores', note que o vet deixou de ser do tipo "float*" e passou a ser do tipo "float**" (com dois asteriscos). O motivo disso é porque no main ele já era um ponteiro (ou seja, era do tipo "float*" e representava um endereço na memória) e como você tá passando ele por referência pra função vetores, então tá passando o endereço dele, então a função vetores vai enxergar ele como um endereço de um endereço. Esse era o motivo do erro do teu código.

Uma outra coisa que tava errada era a tua declaração do malloc.
O parâmetro que o malloc recebe vai dizer o quanto de memória ele vai alocar pro teu ponteiro, em bytes.
Então "malloc(quantElem)" vai alocar um número de bytes igual ao valor de quantElem... o problema disso é que um float nem sempre ocupa apenas um byte. Depende do compilador, do sistema operacional, etc.

Pra ficar seguro, você usa "malloc(sizeof(float) * x)", onde 'x' é a quantidade de elementos que você quer alocar pra aquele vetor.

Daí considerando isso, você agora precisa ter alguns cuidados dentro da função 'vetores':

- Como 'quantElem' foi passado por referência, você usa "*quantElem" pra acessar o valor dele e apenas "quantElem" pra acessar o endereço dele. Como a função scanf espera o endereço de uma variável como argumento, então você usa "scanf(..., quantElem)" em vez de "scanf(..., &quantElem)".

- Mesma coisa com o 'vet'. A variável 'vet' apenas (sem os asteriscos), representa o endereço do teu ponteiro. Então no malloc você usa "*vet = malloc(...)" pois daí vai estar guardando o resultado do malloc no ponteiro em si, e não no endereço dele.

- Pra passar o 'vet' pelo scanf você faz uma gambiarra aqui: "&(*vet)"
(*vet) é o teu ponteiro em si.
(*vet) é o teu ponteiro acessando a posição 'i' do espaço de memória dele
E como a função scanf espera o endereço como parâmetro, você passa o endereço disso tudo aí, que é "&(*vet)"

É isso.
Desculpa pelo texto enorme.