I want to use a nested structure, but I don't know how to enter data in it. For example:
struct A {
int data;
struct B;
};
struct B {
int number;
};
So in main() when I come to use it:
int main() {
A stage;
stage.B.number;
}
Is that right? If not how do I use it?
Each member variable of a struct generally has a name and a type. In your code, the first member of A has type int and name data. The second member only has a type. You need to give it a name. Let's say b:
struct A {
int data;
B b;
};
To do that, the compiler needs to already know what B is, so declare that struct before you declare A.
To access a nested member, refer to each member along the path by name, separated by .:
A stage;
stage.b.number = 5;
struct A {
struct B {
int number;
};
B b;
int data;
};
int main() {
A a;
a.b.number;
a.data;
}
struct B { // <-- declare before
int number;
};
struct A {
int data;
B b; // <--- declare data member of `B`
};
Now you can use it as,
stage.b.number;
The struct B within A must have a name of some sort so you can reference it:
struct B {
int number;
};
struct A {
int data;
struct B myB;
};
:
struct A myA;
myA.myB.number = 42;
struct A
{
int data;
struct B
{
int number;
}b;
};
int main()
{
A stage = { 42, {100} };
assert(stage.data == 42);
assert(stage.b.number == 100);
}
struct TestStruct {
short Var1;
float Var2;
char Var3;
struct TestStruct2 {
char myType;
CString myTitle;
TestStruct2(char b1,CString b2):myType(b1), myTitle(b2){}
};
std::vector<TestStruct2> testStruct2;
TestStruct(short a1,float a2,char a3): Var1(a1), Var2(a2), Var3(a3) {
testStruct2.push_back(TestStruct2(0,"Test Title"));
testStruct2.push_back(TestStruct2(4,"Test2 Title"));
}
};
std::vector<TestStruct> testStruct;
//push smthng to vec later and call
testStruct.push_back(TestStruct(10,55.5,100));
TRACE("myTest:%s\n",testStruct[0].testStruct2[1].myTitle);
I have somewhat like the following code running for a while live now and it works.
// define a timer
struct lightTimer {
unsigned long time; // time in seconds since midnight so range is 0-86400
byte percentage; // in percentage so range is 0-100
};
// define a list of timers
struct lightTable {
lightTimer timer[50];
int otherVar;
};
// and make 5 instances
struct lightTable channel[5]; //all channels are now memory allocated
#zx485: EDIT: Edited/cleaned the code. Excuse for the raw dump.
Explanation:
Define a lightTimer. Basically a struct that contains 2 vars.
struct lightTimer {
Define a lightTable. First element is a lightTimer.
struct lightTable {
Make an actual (named) instance:
struct lightTable channel[5];
We now have 5 channels with 50 timers.
Access like:
channel[5].timer[10].time = 86400;
channel[5].timer[10].percentage = 50;
channel[2].otherVar = 50000;
Related
I have C-code that I need to compile to C++ and need to minimally change it.
In C, the following works
typedef struct _type_t
{
int a;
int b;
int c[];
}type_t;
type_t var = {1,2,{1,2,3}};
But in C++11, it gives the error
error: too many initializers for int [0]
But I cannot give type_t.c a constant size because it needs to work for any size array.
So I need to change the struct to
typedef struct _type_t
{
int a;
int b;
int *c;
}type_t;
But then I need to change
type_t var = {1,2,{1,2,3}};
to something else because current code gives the error
error: braces around scalar initializer for type int*
Casting 3rd element to(int[]) gives error
error: taking address of temporary array
This is from micropython, parse.c:
#define DEF_RULE_NC(rule, kind, ...) static const rule_t rule_##rule = { RULE_##rule, kind, #rule, { __VA_ARGS__ } };
How do I initialize the array and assign it to type_t.c ?
Use std::vector and aggregate initialization:
struct type_t
{
int a;
int b;
std::vector<int> c;
};
int main() {
type_t var = { 1, 2, { 1, 2, 3 } };
}
In order to do this you need to make your array really static:
typedef struct _type_t
{
int a;
int b;
int * c;
}type_t;
int items[3] = {1,2,3};
type_t var = {1,2, static_cast< int * >(items)};
C++ doesn't allow this statement expression. You may use lightweight std::initialiser_list to achieve the objective
#include <initializer_list>
typedef struct _type_t
{
int a;
int b;
std::initializer_list<int> c;
}type_t;
type_t var = {1,2,{1,2,3,4}};
yet another alternative might be
...
int * c;
}type_t;
type_t var = {1,2, []{ static int x[] = {1,2,3}; return x; }() };
PS: yes, I know it's crazy, but it's somewhat more respectful of OP requirements ( it can be incorporated in a dropin replacement macro as given )
I have a chicken and the egg problem. I want to pass a data struct to a routine which contains a pointer to a routine who needs the struct.
I made a very simple example.
I need to use the CalcDataStruct before it's defined, if I add it after the struct, the FuntctionPrototype is not defined.
The problem i run against is only in the first 2 lines, the rest may contain a few syntax errors because I have not checked this inside the compiler.
typedef void(*FunctionPrototype)(CalcDataStruct *Ptr);
struct CalcDataStruct
{
int A, B, C, D;
int Values;
char SignA, Sign B;
int Result;
FunctionPrototype Routine;
}
struct ScanStruct
{
char Sign;
int Values;
FunctionPrototype Routine;
};
const ScanStruct ExampleList[] =
{
{ '+', 2, AddTwo },
{ '+', 3, AddThree }
};
void AddTwo(CalcDataStruct *Ptr)
{
// use the data and if needed put it back
}
void AddThree(CalcDataStruct *Ptr)
{
// use the data and if needed put it back
}
void GetFunction(CalcDataStuct *Ptr, ScanStruct *List)
{
// Very simple return based on nothing
Ptr->Routine = *List[(1)].Routine;
}
void main()
{
CalcDataStruct A;
// struct is filled
// Fill in the routine pointer based on data
GetFunction(A, ExampleList)
// Execute the routine fetched with all the data
A->Routine(A)
}
You need to add a forward declaration (see below).
struct CalcDataStruct; will just declare that struct CalcDataStruct exists, so the typedef void(*FunctionPrototype)(CalcDataStruct *Ptr); declaration will succeed because now the compiler knows that struct CalcDataStruct exists but without knowing the details of the struct, which doesn't matter because all the FunctionPrototype declaration needs is to know that the parameter is a pointer to struct CalcDataStruct.
struct CalcDataStruct; // <<< add this
typedef void(*FunctionPrototype)(CalcDataStruct *Ptr);
struct CalcDataStruct
{
int A, B, C, D;
int Values;
char SignA, Sign B;
int Result;
FunctionPrototype Routine;
}
How can we access a structure's member without knowing the name of it?
For example : This is my struct.
struct A
{
int a;
char b;
int c;
}
Now I want to access char member of the struct A without using it's name.
I have only a pointer to that structure.
Example : struct A *temp;
Now I need to access with 'temp'.
I know the question is simillar to this How would you access a C structure's members without knowing the name?,
but it doesn't clarified my doubt.
From the comments, I understand you have the following function
struct A;
void foo( struct A * temp )
{
// access temp->b here
}
If you can include the file that has struct A's definition, do so
#include "A.h"
void foo( struct A * temp )
{
do_something_with_b(temp->b);
}
If you can't include the file, do what Luc Forget suggested in his answer:
Declare a struct B with identical structure, and cast temp to struct B. Because struct B have the same memory layout as struct A, accessing ((struct B*)temp)->e is identical to accessing A->b.
If you what are the structure fields, I think the simplest way of accessing the fields is to declare another structure Struct B with the same fields and casting your struct A* to struct B and then accessing the fields in a "traditional" way.
Here is a simple example of what I mean :
#include <stdlib.h>
#include <stdio.h>
struct A {
int a;
char b;
int c;
};
struct B {
int d;
char e;
int f;
};
void printStruct(void* struct_ptr)
{
struct B *tmp = struct_ptr;
fprintf(stdout, "a:%d b:%c c:%d\n", tmp->d, tmp->e, tmp->f);
}
int main(int argc, char** argv)
{
struct A test = { 42, 'A', 24 };
printStruct(&test);
}
Here printStruct "doesn't know" the field names of Struct A but can access them
If You know the types and order of members (as well as packing) then You can create another struct and cast a pointer, like so:
struct AMirror {
int a;
char b;
int c;
};
void function_to_use_struct(AMirror *ptr);
...
A *s;
...
function_to_use_struct((AMirror*)s);
The below code should work
void *b=temp;
int *c = (int *) b;
cout<<"Value1: "<<*c <<endl;
char *cc =(char *) (b+4);
cout<<"Char1: "<<*cc<<endl;
c =(int *) (b+6);
cout<<"Value2: "<<*c<<endl;
I guess one way is to cast and increment the char* , but in this case you must know the types and order of declarations of your members.
So, it's possible to declalre anonymous class or struct but how to I make it useful?
int main() {
class{
int ClassVal;
};
struct{
short StructVal;
};
StructVal = 5; //StructVal is undefined
ClassVal = 5; //ClassVal is undefined too?
return 0;
}
if you put both of them outside of main function they will be inaccessible as well.
I'm asking this only because it's somehow intersting :)
EDIT:
Why union outside of main function (at global scope) must be static declared
for example:
static struct {
int x;
};
int main() {
//...
}
Anonymous classes and structures may be used to directly define a variable:
int main()
{
class
{
int ClassVal;
} classVar;
struct
{
short StructVal;
} structVar;
structVar.StructVal = 5;
classVar.ClassVal = 5;
return 0;
}
The above is not very common like that, but very common when used in unions as described by Simon Richter in his answer.
These are most useful in the form of nested struct and union:
struct typed_data {
enum type t;
union {
int i; // simple value
struct {
union { // any of these need a length as well
char *cp;
unsigned char *ucp;
wchar_t *wcp;
};
unsigned int len;
};
};
};
Now typed_data is declared as a type with the members t, i, cp, ucp, wcp and len, with minimal storage requirements for its intended use.
Can a struct contain other structs?
I would like to make a struct that holds an array of four other structs. Is this possible? What would the code look like?
Yes, you can. For example, this struct S2 contains an array of four S1 objects:
struct S1 { int a; };
struct S2
{
S1 the_array[4];
};
Sure, why not.
struct foo {
struct {
int a;
char *b;
} bar[4];
} baz;
baz.bar[1].a = 5;
Yes, structs can contain other structs. For example:
struct sample {
int i;
char c;
};
struct b {
struct sample first;
struct sample second;
};