//This type provides the accessor functions that unify swizzle and vector access
//using array syntax at runtime
//this makes it easy to implement free functions that iterate over the elements of a given vector.
template<typename T, size_t N, size_t... remainder>
struct Swizzle
{
static constexpr size_t indices[N] = { remainder... };
T& operator[] (int index)
{
//cast to base data type, increment by value at index, then dereference
return *((T*)this + indices[index]);
}
T operator[] (int index) const
{
//cast to base datatype, increment, then dereference
return *((T*)this + indices[index]);
}
};
//namespace scope declaration of our index arrays
template<typename T, size_t N, size_t... remainder>
constexpr size_t Swizzle<T,N,remainder...>::indices[];
template<typename T, size_t N>
struct Swizzle<T, N>
{
T& operator[] (int index)
{
return *((T*)this + index);
}
T operator[] (int index) const
{
return *((T*)this + index);
}
}; template<typename T, size_t N, size_t... rem1, size_t... rem2>
void myFunction(Swizzle<T,N,rem1...> &lhs, Swizzle<T,N,rem2...> &rhs)
{
Vector<T,N> out;
cout << lhs << '\n' << rhs << '\n';
for(size_t i = 0; i < N; i++)
{
out[i] = lhs[i] + rhs[i];
}
cout << out;
} //sizeof Vector<float,2> remains 8
template<typename T>
struct Vector<T,2> : public Swizzle<T,2>
{
union
{
T data[2];
Swizzle<T, 1, 0> x, s, u;
Swizzle<T, 1, 1> y, t, v;
Swizzle<T, 2, 0, 0> xx, ss, uu;
Swizzle<T, 2, 0, 1> xy, st, uv;
Swizzle<T, 2, 1, 0> yx, ts, vu;
Swizzle<T, 2, 1, 1> yy, tt, vv;
};
};typedef Vector<float, 2> vec2;
vec2 v = vec2(0.4f, 0.5f);
v.yx += v.ss;Why not GLM?
#include <iostream>
using namespace std;
int main() {
//Program to print out the first, second, ... n word of a sentence.
//Ask user for the sentence
string sentence;
cout << "Please enter a sentence:" << endl;
getline(cin, sentence);
//Sentence cannot begin with spaces.
while(sentence[0] == ' ')
{
cout << "Sentence cannot begin with a space. Please try again." << endl;
cin.clear();
cin.ignore();
getline(cin, sentence);
}
//Ask the user for n
int n;
cout << "Choose the word to be printed out by typing." << endl;
cout << "(Ex: For the first word, type 1; for the second, type 2, etc.):";
cin >> n;
int i; //position in string
int p = 1; //counter for loop
string word;
while(p <= n)
{
//prints out pth word character by character
while(sentence[i] != ' ')
{
word = word + sentence[i];
i++;
}
//moves through all spaces after pth word
while(sentence[i] == ' ')
{
i++;
}
//If not the word user is looking for, erases word to start over
if(p < n)
word = "";
p++;
}
cout << word;
}Think about what happens in this loop when it's the last word. Let's assume we only have one word: 'word'. We get 'w', then 'o', then 'r', then 'd'... then what? Certainly not a space, so the loop won't quit. You loop until you find a space, regardless of whether the string has ended or not. You need to add some kind of condition so the loop doesn't go on if you've already gone through all of the string.
In practice, std::string instances are null-terminated to satisfy the requirements of operator[] and c_str(). Specifically:
C++11 operator docs said:
c_str docs said:
int l;
l = sentence.length() - 1;
while(sentence[i] != ' ' && i < l)
{
word = word + sentence[i];
i++;
}
if(i == l)
{
word = word + sentence[i];
}
while(sentence[i] == ' ')
{
i++;
} if(i == l)
{
word = word + sentence[i];
}
else
{
while(sentence[i] == ' ')
{
i++;
}
}My coworker used F# for making a data-driven Unity application. Kinda neat since it's not officially supported by Unity but it works because F# and C# use the same IL. Pattern matching and pipe operator were the main features he mentioned. I'll probably supplement my own C# with F# eventually.
int evens = 0, odds = 0;
int i = 1;
while (i <= 100) {
if (i%2 == 0) { //is i divisible by 2? if yes then add to evens
evens++;
}
else {
odds++; //i isn't divisible by 2, add to odds
}
i++;
}int evens = 0, numbers = 0;
int i = 1;
while (i <= 100) {
if (i%2 == 0) { //is i divisible by 2? if yes then add to evens
evens++;
}
numbers++; //doesn't matter if i is divisible by 2, just add it to numbers
i++;
}
Noted! Thank you.
In Icefinger Ford are four goblins, a bundle of kindling and a cracked cooking pot.
The kindling is wood. The pot is clay. Instead of burning the kindling, say "The kindling is
hopelessly too damp to catch light, even if you had something to light it with. Goblins
[italic type]have[roman type] discovered fire, but they do keep forgetting the essential
points." Effect of casting mend at the cooking pot: record outcome "but the pot isn't
broken, as such: it was just badly made in the first place"; rule succeeds.