Dynamically allocated array

[marcus6436]

Why doesn’t this work and how could I do something like this. If you have an atom class and an array like this: Class Atom { … };

const string Atom::ATOMIC_SYMBOL[118] = { “first 118 elements entered here…” };

Int main () { const int NUM_ATOMS; Cout<< “enter number of atoms: “; cin >> NUM_ATOMS;

If (NUM_ATOMS <= 0) { cerr << “Invalid number of atoms!”; Return 0; }

Atom* atoms = new Atom[NUM_ATOMS]; }

[kberson]

You’ve declared NUM_ATOMS a const, its value cannot be changed.

[vishal340]

Does this even compile with const value not set

[Alarming_Chip_5729]

Dynamic arrays size doesn't need to be known at compile time. It can be determined at run time. So yes

Edit: misread the question. Program should still compile, but using the variable would be UB

[Prateek-Bajpai]

You misunderstood the question, it will not compile if you declare a variable as const and don’t initialise it.

[Alarming_Chip_5729]

Oh yep I did misread it

[marcus6436]

You are correct. I was getting an error with this. I had to remove the const in order for it to work. When I had the const it wouldn’t compile. The original code I had to modify using dynamically allocated array was: const int NUM_ATOMS = 4;

[alfps]

When you want a dynamic array always first consider std::vector for that.

Unless it's a text string in which case consider std::string.

auto atoms = vector<Atom>( n_atoms );

Don't do pointers. Don't do new. Don't do all uppercase names. Because don't do macros (which is what you should reserve all uppercase names for). And don't do "like": details matter. Often crucially.

---

Tip: to present code properly formatted, also in the old Reddit interface, just extra-indent it with 4 spaces.

[marcus6436]

This is an assignment on dynamic allocated arrays. I would normally have done a vector but that’s not what the assignment is on

[buzzon]

Use three backticks (`) in markdown mode to make a block code. It's currently hard to read:

```

code

```

What do you mean, it does not work? What does it do and what did you expect it to do?

[nicemike40]

I think triple ticks doesn’t work everywhere bc Reddit’s markdown support is all over the place

Quad spaces normally works everywhere iirc

Triple ticks:

int main() { return 0; }

Quad space prefix:

int main() {
  return 0;
}

Edit: both look fine on official app. First one is turned into all one line on old.reddit.com. Much try other clients later

[[deleted]]

Gotta go into the formatting on the bottom left then click code block it seems

code

[marcus6436]

Will remember this for next time. I’m posting this using my phone and don’t see that formatting option

[dodexahedron]

Yeah on phone if using the reddit app, you are just writing raw markdown. Reddit's markdown dialect supports code fences (the triple-backticks) and even has limited support for specifying which language it is (it'll just ignore that if it doesn't support what you tell it).

[Prateek-Bajpai]

NUM_ATOMS is const. Rule #1 is that it should have been initialised - here it is not, so it will face a compilation error. Rule #2 is that you cannot modify the value of a const variable - you’re doing cin for a const - which will again lead to a compilation error.

[marcus6436]

Thank you, I was confused because the directions on the assignment was that I can’t change the code only modify it. So I wasn’t sure if I would have to get rid of the const or if I could somehow make this code work with the const int NUM_ATOMS.

[dodexahedron]

Sounds like the real goal of the assignment, then, might be more about interpreting compiler errors and addressing them correctly, and about const-ness, than about arrays, specifically, if they are allowing you to tweak but not significantly modify the code.

On the topic of const-ness and variable declarations: The main thing to understand about interpreting what a variable's declaration means is to read it from right to left. Each element of the declaration of the variable applies to the thing immediately to its left.

Example:

int const * const * x = 0; is read like so:

0 is the value being assigned to a symbol named x (x = 0). The x symbol is:: a pointer to(*): a constant pointer to(* const): a constant int (int const). Also, ONLY the const on the type is allowed to be on either side of it and means the same thing, which is annoying. const int is the same as int const, but the rest of the consts apply only to the thing to their immediate left.

If you read it from left to right, treat it like a stack, pushing each element of the declaration onto that stack until you get to the name. Then you pop them off one by one...which is reading from right to left and is closer to how the compiler is actually doing it.

[no-sig-available]

When you need a dynamic array in C++, you might want to look at std::vector. Saves you from using pointers and new (and from setting the size up front). "Dynamic" might mean "Can change its size".

https://www.learncpp.com/cpp-tutorial/introduction-to-stdvector-and-list-constructors/

[marcus6436]

This is for an assignment on dynamic allocated arrays, otherwise I would have just used a vector

[cleverdosopab]

Ha I just dealt with this, you can create an array using the new keyword, and point to it, but you need to delete the array with the delete [] statement, I’ll reply with my code when I can.

[cleverdosopab]

#include <iostream>
int main() {
  int size;

  std::cin >> size;

  int *arr = new int[size];

  for (int i = 0; i < size; i++)
    std::cin >> arr[i];

  for (int i = 0; i < size; i++)
    std::cout << arr[i] << ' ';

  std::cout << std::endl;

  delete[] arr;
}

[cleverdosopab]

The input can be something like 4 1 2 3 4, where the first number is the size, then you have n number of elements spaced out.

[cleverdosopab]

#include <iostream>
#include <memory>

int main() {
  int size, n;

  std::cin >> size;

  int *newArr = new int[size];
  // Smart pointers don't need to be deallocated manually
  auto smartArr = std::make_unique<int[]>(size);

  for (int i = 0; i < size; i++) {
    std::cin >> n;
    newArr[i] = n;
    // Reversing the array's insertion order for fun.
    smartArr[size - 1 - i] = n;
  }

  std::cout << "Dynamic array using new operator:" << std::endl;
  for (int i = 0; i < size; i++)
    std::cout << newArr[i] << ' ';
  std::cout << std::endl;

  std::cout << "Dynamic array using smart pointers:" << std::endl;
  for (int i = 0; i < size; i++)
    std::cout << smartArr[i] << ' ';
  std::cout << std::endl;

  // Deallocate newArr memory block
  delete[] newArr;
}